27.4 Header <algorithm> synopsis [algorithm.syn] C++N4910:2022 (658) p1153.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.4 Header <algorithm> synopsis [algorithm.syn] C++N4910:2022 (658) p1153.cpp

## 算譜(source code)

```c++:p1153.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.4 Header <algorithm> synopsis [algorithm.syn] C++N4910:2022 (658) p1153.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;

// 27.4 Header <algorithm> synopsis  [algorithm.syn]
#include <initializer_list>
namespace std {
namespace ranges {
// 27.5, algorithm result types
template<class I, class F>
struct in_fun_result;
template<class I1, class I2>
struct in_in_result;
template<class I, class O>
struct in_out_result;
template<class I1, class I2, class O>
struct in_in_out_result;
template<class I, class O1, class O2>
struct in_out_out_result;
template<class T>
struct min_max_result;
template<class I>
struct in_found_result;
template<class O, class T>
struct out_value_result;
}
// 27.6, non-modifying sequence operations
// 27.6.1, all of
template<class InputIterator, class Predicate>
constexpr bool all_of(InputIterator first, InputIterator last, Predicate pred);
template<class ExecutionPolicy, class ForwardIterator, class Predicate>
bool all_of(ExecutionPolicy&& exec, // see 27.3.5
            ForwardIterator first, ForwardIterator last, Predicate pred);
namespace ranges {
template<input_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_unary_predicate<projected<I, Proj>> Pred>
constexpr bool all_of(I first, S last, Pred pred, Proj proj = {});
template<input_range R, class Proj = identity,
         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
constexpr bool all_of(R&& r, Pred pred, Proj proj = {});
}
// 27.6.2, any of
template<class InputIterator, class Predicate>
constexpr bool any_of(InputIterator first, InputIterator last, Predicate pred);
template<class ExecutionPolicy, class ForwardIterator, class Predicate>
bool any_of(ExecutionPolicy&& exec, // see 27.3.5
            ForwardIterator first, ForwardIterator last, Predicate pred);
namespace ranges {
template<input_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_unary_predicate<projected<I, Proj>> Pred>
constexpr bool any_of(I first, S last, Pred pred, Proj proj = {});
template<input_range R, class Proj = identity,
         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
constexpr bool any_of(R&& r, Pred pred, Proj proj = {});
}
// 27.6.3, none of
template<class InputIterator, class Predicate>
constexpr bool none_of(InputIterator first, InputIterator last, Predicate pred);
template<class ExecutionPolicy, class ForwardIterator, class Predicate>
bool none_of(ExecutionPolicy&& exec, // see 27.3.5
             ForwardIterator first, ForwardIterator last, Predicate pred);
namespace ranges {
template<input_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_unary_predicate<projected<I, Proj>> Pred>
constexpr bool none_of(I first, S last, Pred pred, Proj proj = {});
template<input_range R, class Proj = identity,
         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
constexpr bool none_of(R&& r, Pred pred, Proj proj = {});
}
// 27.6.4, for each
template<class InputIterator, class Function>
constexpr Function for_each(InputIterator first, InputIterator last, Function f);
template<class ExecutionPolicy, class ForwardIterator, class Function>
void for_each(ExecutionPolicy&& exec, // see 27.3.5
              ForwardIterator first, ForwardIterator last, Function f);
namespace ranges {
template<class I, class F>
using for_each_result = in_fun_result<I, F>;
template<input_iterator I, sentinel_for<I> S, class Proj = identity,
         indirectly_unary_invocable<projected<I, Proj>> Fun>
constexpr for_each_result<I, Fun>
for_each(I first, S last, Fun f, Proj proj = {});
template<input_range R, class Proj = identity,
         indirectly_unary_invocable<projected<iterator_t<R>, Proj>> Fun>
constexpr for_each_result<borrowed_iterator_t<R>, Fun>
for_each(R&& r, Fun f, Proj proj = {});
}
template<class InputIterator, class Size, class Function>
constexpr InputIterator for_each_n(InputIterator first, Size n, Function f);
template<class ExecutionPolicy, class ForwardIterator, class Size, class Function> ForwardIterator for_each_n(ExecutionPolicy&& exec, // see 27.3.5
        ForwardIterator first, Size n, Function f);
namespace ranges {
template<class I, class F>
using for_each_n_result = in_fun_result<I, F>;
template<input_iterator I, class Proj = identity,
         indirectly_unary_invocable<projected<I, Proj>> Fun>
constexpr for_each_n_result<I, Fun>
for_each_n(I first, iter_difference_t<I> n, Fun f, Proj proj = {});
}
// 27.6.5, find
template<class InputIterator, class T>
constexpr InputIterator find(InputIterator first, InputIterator last,
                             const T& value);
template<class ExecutionPolicy, class ForwardIterator, class T> ForwardIterator find(ExecutionPolicy&& exec, // see 27.3.5
        ForwardIterator first, ForwardIterator last,
        const T& value);
template<class InputIterator, class Predicate>
constexpr InputIterator find_if(InputIterator first, InputIterator last,
                                Predicate pred);
template<class ExecutionPolicy, class ForwardIterator, class Predicate> ForwardIterator find_if(ExecutionPolicy&& exec, // see 27.3.5
        ForwardIterator first, ForwardIterator last,
        Predicate pred);
template<class InputIterator, class Predicate>
constexpr InputIterator find_if_not(InputIterator first, InputIterator last,
                                    Predicate pred);
template<class ExecutionPolicy, class ForwardIterator, class Predicate> ForwardIterator find_if_not(ExecutionPolicy&& exec, // see 27.3.5
        ForwardIterator first, ForwardIterator last,
        Predicate pred);
namespace ranges {
template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
constexpr I find(I first, S last, const T& value, Proj proj = {});
template<input_range R, class T, class Proj = identity>
requires indirect_binary_predicate<ranges::equal_to,
         projected<iterator_t<R>, Proj>, const T*>
         constexpr borrowed_iterator_t<R>
         find(R&& r, const T& value, Proj proj = {});
template<input_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_unary_predicate<projected<I, Proj>> Pred>
constexpr I find_if(I first, S last, Pred pred, Proj proj = {});
template<input_range R, class Proj = identity,
         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
constexpr borrowed_iterator_t<R>
find_if(R&& r, Pred pred, Proj proj = {});
template<input_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_unary_predicate<projected<I, Proj>> Pred>
constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {});
template<input_range R, class Proj = identity,
         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
constexpr borrowed_iterator_t<R>
}
find_if_not(R&& r, Pred pred, Proj proj = {});
// 27.6.6, find end
template<class ForwardIterator1, class ForwardIterator2>
constexpr ForwardIterator1
find_end(ForwardIterator1 first1, ForwardIterator1 last1,
         ForwardIterator2 first2, ForwardIterator2 last2);
template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
constexpr ForwardIterator1
find_end(ForwardIterator1 first1, ForwardIterator1 last1,
         ForwardIterator2 first2, ForwardIterator2 last2,
         BinaryPredicate pred);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator1
find_end(ExecutionPolicy&& exec, // see 27.3.5
         ForwardIterator1 first1, ForwardIterator1 last1,
         ForwardIterator2 first2, ForwardIterator2 last2);
template<class ExecutionPolicy, class ForwardIterator1,
         class ForwardIterator2, class BinaryPredicate>
ForwardIterator1
find_end(ExecutionPolicy&& exec,
         ForwardIterator1 first1, ForwardIterator1 last1,
         ForwardIterator2 first2, ForwardIterator2 last2,
         BinaryPredicate pred);
// see 27.3.5
namespace ranges {
template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
constexpr subrange<I1>
find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
         Proj1 proj1 = {}, Proj2 proj2 = {});
template<forward_range R1, forward_range R2,
         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
constexpr borrowed_subrange_t<R1>
find_end(R1&& r1, R2&& r2, Pred pred = {},
         Proj1 proj1 = {}, Proj2 proj2 = {});
}
// 27.6.7, find first
template<class InputIterator, class ForwardIterator>
constexpr InputIterator
find_first_of(InputIterator first1, InputIterator last1,
              ForwardIterator first2, ForwardIterator last2);
template<class InputIterator, class ForwardIterator, class BinaryPredicate>
constexpr InputIterator
find_first_of(InputIterator first1, InputIterator last1,
              ForwardIterator first2, ForwardIterator last2,
              BinaryPredicate pred);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator1
find_first_of(ExecutionPolicy&& exec, // see 27.3.5
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2);
template<class ExecutionPolicy, class ForwardIterator1,
         class ForwardIterator2, class BinaryPredicate>
ForwardIterator1
find_first_of(ExecutionPolicy&& exec, // see 27.3.5
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
namespace ranges {
template<input_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
constexpr I1 find_first_of(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
                           Proj1 proj1 = {}, Proj2 proj2 = {});
template<input_range R1, forward_range R2,
         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
constexpr borrowed_iterator_t<R1>
find_first_of(R1&& r1, R2&& r2, Pred pred = {},
              Proj1 proj1 = {}, Proj2 proj2 = {});
}
// 27.6.8, adjacent find
template<class ForwardIterator>
constexpr ForwardIterator
adjacent_find(ForwardIterator first, ForwardIterator last);
template<class ForwardIterator, class BinaryPredicate>
constexpr ForwardIterator
adjacent_find(ForwardIterator first, ForwardIterator last,
              BinaryPredicate pred);
template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator
adjacent_find(ExecutionPolicy&& exec, // see 27.3.5
              ForwardIterator first, ForwardIterator last);
template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>
ForwardIterator
adjacent_find(ExecutionPolicy&& exec, // see 27.3.5
              ForwardIterator first, ForwardIterator last,
              BinaryPredicate pred);
namespace ranges {
template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_binary_predicate<projected<I, Proj>,
                                   projected<I, Proj>> Pred = ranges::equal_to>
constexpr I adjacent_find(I first, S last, Pred pred = {},
                          Proj proj = {});
template<forward_range R, class Proj = identity,
         indirect_binary_predicate<projected<iterator_t<R>, Proj>,
// 27.6.9, count
                                   template<class InputIterator, class T>
                                   constexpr typename iterator_traits<InputIterator>::difference_type
                                   count(InputIterator first, InputIterator last, const T& value);
         template<class ExecutionPolicy, class ForwardIterator, class T>
         typename iterator_traits<ForwardIterator>::difference_type
         count(ExecutionPolicy&& exec, // see 27.3.5
               ForwardIterator first, ForwardIterator last, const T& value);
         template<class InputIterator, class Predicate>
         constexpr typename iterator_traits<InputIterator>::difference_type
         count_if(InputIterator first, InputIterator last, Predicate pred);
         template<class ExecutionPolicy, class ForwardIterator, class Predicate>
         typename iterator_traits<ForwardIterator>::difference_type count_if(ExecutionPolicy&& exec, // see 27.3.5
                 ForwardIterator first, ForwardIterator last, Predicate pred);
         projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
                 adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
         constexpr borrowed_iterator_t<R>
}
         namespace ranges {
template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
constexpr iter_difference_t<I>
count(I first, S last, const T& value, Proj proj = {});
template<input_range R, class T, class Proj = identity>
requires indirect_binary_predicate<ranges::equal_to,
                                   projected<iterator_t<R>, Proj>, const T*>
constexpr range_difference_t<R>
count(R&& r, const T& value, Proj proj = {});
template<input_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_unary_predicate<projected<I, Proj>> Pred>
constexpr iter_difference_t<I>
count_if(I first, S last, Pred pred, Proj proj = {});
template<input_range R, class Proj = identity,
         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
constexpr range_difference_t<R>
count_if(R&& r, Pred pred, Proj proj = {});
}
// 27.6.10, mismatch
template<class InputIterator1, class InputIterator2>
constexpr pair<InputIterator1, InputIterator2>
mismatch(InputIterator1 first1, InputIterator1 last1,
         InputIterator2 first2);
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
constexpr pair<InputIterator1, InputIterator2>
mismatch(InputIterator1 first1, InputIterator1 last1,
         InputIterator2 first2, BinaryPredicate pred);
template<class InputIterator1, class InputIterator2>
constexpr pair<InputIterator1, InputIterator2>
mismatch(InputIterator1 first1, InputIterator1 last1,
         InputIterator2 first2, InputIterator2 last2);
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
constexpr pair<InputIterator1, InputIterator2>
mismatch(InputIterator1 first1, InputIterator1 last1,
         InputIterator2 first2, InputIterator2 last2,
         BinaryPredicate pred);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
pair<ForwardIterator1, ForwardIterator2>
mismatch(ExecutionPolicy&& exec, // see 27.3.5
         ForwardIterator1 first1, ForwardIterator1 last1,
         ForwardIterator2 first2);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class BinaryPredicate>
pair<ForwardIterator1, ForwardIterator2>
mismatch(ExecutionPolicy&& exec, // see 27.3.5
         ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, BinaryPredicate pred);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
pair<ForwardIterator1, ForwardIterator2>
mismatch(ExecutionPolicy&& exec, // see 27.3.5
         ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class BinaryPredicate>
pair<ForwardIterator1, ForwardIterator2>
mismatch(ExecutionPolicy&& exec,
         ForwardIterator1 first1, ForwardIterator1 last1,
         ForwardIterator2 first2, ForwardIterator2 last2,
         BinaryPredicate pred);
// see 27.3.5
namespace ranges {
template<class I1, class I2>
using mismatch_result = in_in_result<I1, I2>;
template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
constexpr mismatch_result<I1, I2>
mismatch(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
         Proj1 proj1 = {}, Proj2 proj2 = {});
template<input_range R1, input_range R2,
         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
constexpr mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
mismatch(R1&& r1, R2&& r2, Pred pred = {},
         Proj1 proj1 = {}, Proj2 proj2 = {});
}
// 27.6.11, equal
template<class InputIterator1, class InputIterator2>
constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
                     InputIterator2 first2);
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
                     InputIterator2 first2, BinaryPredicate pred);
template<class InputIterator1, class InputIterator2>
constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
                     InputIterator2 first2, InputIterator2 last2);
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
                     InputIterator2 first2, InputIterator2 last2,
                     BinaryPredicate pred);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
bool equal(ExecutionPolicy&& exec, // see 27.3.5
           ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class BinaryPredicate>
bool equal(ExecutionPolicy&& exec, // see 27.3.5
           ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, BinaryPredicate pred);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2> bool equal(ExecutionPolicy&& exec, // see 27.3.5
        ForwardIterator1 first1, ForwardIterator1 last1,
        ForwardIterator2 first2, ForwardIterator2 last2);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class BinaryPredicate>
bool equal(ExecutionPolicy&& exec,
           ForwardIterator1 first1, ForwardIterator1 last1,
           ForwardIterator2 first2, ForwardIterator2 last2,
           BinaryPredicate pred);
// see 27.3.5
namespace ranges {
template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
constexpr bool equal(I1 first1, S1 last1, I2 first2, S2 last2,
                     Pred pred = {},
                     Proj1 proj1 = {}, Proj2 proj2 = {});
template<input_range R1, input_range R2, class Pred = ranges::equal_to,
         class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
constexpr bool equal(R1&& r1, R2&& r2, Pred pred = {},
                     Proj1 proj1 = {}, Proj2 proj2 = {});
}
// 27.6.12, is permutation
template<class ForwardIterator1, class ForwardIterator2>
constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                              ForwardIterator2 first2);
template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                              ForwardIterator2 first2, BinaryPredicate pred);
template<class ForwardIterator1, class ForwardIterator2>
constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                              ForwardIterator2 first2, ForwardIterator2 last2);
template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                              ForwardIterator2 first2, ForwardIterator2 last2,
                              BinaryPredicate pred);
namespace ranges {
template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
         sentinel_for<I2> S2, class Proj1 = identity, class Proj2 = identity,
         indirect_equivalence_relation<projected<I1, Proj1>,
                                       projected<I2, Proj2>> Pred = ranges::equal_to>
constexpr bool is_permutation(I1 first1, S1 last1, I2 first2, S2 last2,
                              Pred pred = {},
                              Proj1 proj1 = {}, Proj2 proj2 = {});
template<forward_range R1, forward_range R2,
         class Proj1 = identity, class Proj2 = identity,
         indirect_equivalence_relation<projected<iterator_t<R1>, Proj1>,
                                       projected<iterator_t<R2>, Proj2>>
         Pred = ranges::equal_to>
constexpr bool is_permutation(R1&& r1, R2&& r2, Pred pred = {},
                              Proj1 proj1 = {}, Proj2 proj2 = {});
}
// 27.6.13, search
template<class ForwardIterator1, class ForwardIterator2>
constexpr ForwardIterator1
search(ForwardIterator1 first1, ForwardIterator1 last1,
       ForwardIterator2 first2, ForwardIterator2 last2);
template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
constexpr ForwardIterator1
search(ForwardIterator1 first1, ForwardIterator1 last1,
       ForwardIterator2 first2, ForwardIterator2 last2,
       BinaryPredicate pred);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator1
search(ExecutionPolicy&& exec, // see 27.3.5
       ForwardIterator1 first1, ForwardIterator1 last1,
       ForwardIterator2 first2, ForwardIterator2 last2);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class BinaryPredicate>
ForwardIterator1
search(ExecutionPolicy&& exec,
       ForwardIterator1 first1, ForwardIterator1 last1,
       ForwardIterator2 first2, ForwardIterator2 last2,
       BinaryPredicate pred);
// see 27.3.5
namespace ranges {
template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
         sentinel_for<I2> S2, class Pred = ranges::equal_to,
         class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
constexpr subrange<I1>
search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
       Proj1 proj1 = {}, Proj2 proj2 = {});
template<forward_range R1, forward_range R2, class Pred = ranges::equal_to,
         class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
constexpr borrowed_subrange_t<R1>
search(R1&& r1, R2&& r2, Pred pred = {},
       Proj1 proj1 = {}, Proj2 proj2 = {});
}
template<class ForwardIterator, class Size, class T>
constexpr ForwardIterator
search_n(ForwardIterator first, ForwardIterator last,
         Size count, const T& value);
template<class ForwardIterator, class Size, class T, class BinaryPredicate>
constexpr ForwardIterator
search_n(ForwardIterator first, ForwardIterator last,
         Size count, const T& value, BinaryPredicate pred);
template<class ExecutionPolicy, class ForwardIterator, class Size, class T>
ForwardIterator
search_n(ExecutionPolicy&& exec, // see 27.3.5
         ForwardIterator first, ForwardIterator last,
         Size count, const T& value);
template<class ExecutionPolicy, class ForwardIterator, class Size, class T,
         class BinaryPredicate>
ForwardIterator
search_n(ExecutionPolicy&& exec,
         ForwardIterator first, ForwardIterator last,
         Size count, const T& value,
         BinaryPredicate pred);
namespace ranges {
template<forward_iterator I, sentinel_for<I> S, class T,
// see 27.3.5
         class Pred = ranges::equal_to, class Proj = identity>
requires indirectly_comparable<I, const T*, Pred, Proj>
constexpr subrange<I>
search_n(I first, S last, iter_difference_t<I> count,
         const T& value, Pred pred = {}, Proj proj = {});
template<forward_range R, class T, class Pred = ranges::equal_to,
         class Proj = identity>
requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj>
constexpr borrowed_subrange_t<R>
search_n(R&& r, range_difference_t<R> count,
         const T& value, Pred pred = {}, Proj proj = {});
}
template<class ForwardIterator, class Searcher>
constexpr ForwardIterator
search(ForwardIterator first, ForwardIterator last, const Searcher& searcher);
namespace ranges {
// 27.6.14, starts with
template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
constexpr bool starts_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
                           Proj1 proj1 = {}, Proj2 proj2 = {});
template<input_range R1, input_range R2, class Pred = ranges::equal_to,
         class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
constexpr bool starts_with(R1&& r1, R2&& r2, Pred pred = {},
                           Proj1 proj1 = {}, Proj2 proj2 = {});
// 27.6.15, ends with
template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
requires (forward_iterator<I1> || sized_sentinel_for<S1, I1>) &&
(forward_iterator<I2> || sized_sentinel_for<S2, I2>) &&
indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
constexpr bool ends_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
                         Proj1 proj1 = {}, Proj2 proj2 = {});
template<input_range R1, input_range R2, class Pred = ranges::equal_to,
         class Proj1 = identity, class Proj2 = identity>
requires (forward_range<R1> || sized_range<R1>) &&
(forward_range<R2> || sized_range<R2>) &&
indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
constexpr bool ends_with(R1&& r1, R2&& r2, Pred pred = {},
                         Proj1 proj1 = {}, Proj2 proj2 = {});
}
// 27.7, mutating sequence operations
// 27.7.1, copy
template<class InputIterator, class OutputIterator>
constexpr OutputIterator copy(InputIterator first, InputIterator last,
                              OutputIterator result);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2> ForwardIterator2 copy(ExecutionPolicy&& exec, // see 27.3.5
        ForwardIterator1 first, ForwardIterator1 last,
        ForwardIterator2 result);
namespace ranges {
template<class I, class O>
using copy_result = in_out_result<I, O>;
template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
requires indirectly_copyable<I, O>
constexpr copy_result<I, O>
copy(I first, S last, O result);
template<input_range R, weakly_incrementable O>
requires indirectly_copyable<iterator_t<R>, O>
constexpr copy_result<borrowed_iterator_t<R>, O>
copy(R&& r, O result);
}
template<class InputIterator, class Size, class OutputIterator>
constexpr OutputIterator copy_n(InputIterator first, Size n,
                                OutputIterator result);
template<class ExecutionPolicy, class ForwardIterator1, class Size,
         class ForwardIterator2>
ForwardIterator2 copy_n(ExecutionPolicy&& exec,
                        ForwardIterator1 first, Size n,
                        ForwardIterator2 result);
namespace ranges {
template<class I, class O>
using copy_n_result = in_out_result<I, O>;
template<input_iterator I, weakly_incrementable O>
requires indirectly_copyable<I, O>
constexpr copy_n_result<I, O>
copy_n(I first, iter_difference_t<I> n, O result);
}
template<class InputIterator, class OutputIterator, class Predicate>
constexpr OutputIterator copy_if(InputIterator first, InputIterator last,
                                 OutputIterator result, Predicate pred);
// see 27.3.5
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class Predicate>
ForwardIterator2 copy_if(ExecutionPolicy&& exec, // see 27.3.5
                         ForwardIterator1 first, ForwardIterator1 last,
                         ForwardIterator2 result, Predicate pred);
namespace ranges {
template<class I, class O>
using copy_if_result = in_out_result<I, O>;
template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
         indirect_unary_predicate<projected<I, Proj>> Pred>
requires indirectly_copyable<I, O>
constexpr copy_if_result<I, O>
copy_if(I first, S last, O result, Pred pred, Proj proj = {});
template<input_range R, weakly_incrementable O, class Proj = identity,
         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
requires indirectly_copyable<iterator_t<R>, O>
constexpr copy_if_result<borrowed_iterator_t<R>, O>
copy_if(R&& r, O result, Pred pred, Proj proj = {});
}
template<class BidirectionalIterator1, class BidirectionalIterator2>
constexpr BidirectionalIterator2
copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
              BidirectionalIterator2 result);
namespace ranges {
template<class I1, class I2>
using copy_backward_result = in_out_result<I1, I2>;
template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
requires indirectly_copyable<I1, I2>
constexpr copy_backward_result<I1, I2>
copy_backward(I1 first, S1 last, I2 result);
template<bidirectional_range R, bidirectional_iterator I>
requires indirectly_copyable<iterator_t<R>, I>
constexpr copy_backward_result<borrowed_iterator_t<R>, I>
copy_backward(R&& r, I result);
}
// 27.7.2, move
template<class InputIterator, class OutputIterator>
constexpr OutputIterator move(InputIterator first, InputIterator last,
                              OutputIterator result);
template<class ExecutionPolicy, class ForwardIterator1,
         class ForwardIterator2>
ForwardIterator2 move(ExecutionPolicy&& exec, // see 27.3.5
                      ForwardIterator1 first, ForwardIterator1 last,
                      ForwardIterator2 result);
namespace ranges {
template<class I, class O>
using move_result = in_out_result<I, O>;
template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
requires indirectly_movable<I, O>
constexpr move_result<I, O>
move(I first, S last, O result);
template<input_range R, weakly_incrementable O>
requires indirectly_movable<iterator_t<R>, O>
constexpr move_result<borrowed_iterator_t<R>, O>
move(R&& r, O result);
}
template<class BidirectionalIterator1, class BidirectionalIterator2>
constexpr BidirectionalIterator2
move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
              BidirectionalIterator2 result);
namespace ranges {
template<class I1, class I2>
using move_backward_result = in_out_result<I1, I2>;
template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
requires indirectly_movable<I1, I2>
constexpr move_backward_result<I1, I2>
move_backward(I1 first, S1 last, I2 result);
template<bidirectional_range R, bidirectional_iterator I>
requires indirectly_movable<iterator_t<R>, I>
constexpr move_backward_result<borrowed_iterator_t<R>, I>
move_backward(R&& r, I result);
}
// 27.7.3, swap
template<class ForwardIterator1, class ForwardIterator2>
constexpr ForwardIterator2 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1,
                                       ForwardIterator2 first2);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2> ForwardIterator2 swap_ranges(ExecutionPolicy&& exec, // see 27.3.5
        ForwardIterator1 first1, ForwardIterator1 last1,
        ForwardIterator2 first2);
namespace ranges {
template<class I1, class I2>
using swap_ranges_result = in_in_result<I1, I2>;
template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2>
requires indirectly_swappable<I1, I2>
constexpr swap_ranges_result<I1, I2>
swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
template<input_range R1, input_range R2>
requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
constexpr swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
swap_ranges(R1&& r1, R2&& r2);
}
template<class ForwardIterator1, class ForwardIterator2>
constexpr void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
// 27.7.4, transform
template<class InputIterator, class OutputIterator, class UnaryOperation>
constexpr OutputIterator
transform(InputIterator first1, InputIterator last1,
          OutputIterator result, UnaryOperation op);
template<class InputIterator1, class InputIterator2, class OutputIterator,
         class BinaryOperation>
constexpr OutputIterator
transform(InputIterator1 first1, InputIterator1 last1,
          InputIterator2 first2, OutputIterator result,
          BinaryOperation binary_op);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class UnaryOperation>
ForwardIterator2
transform(ExecutionPolicy&& exec, // see 27.3.5
          ForwardIterator1 first1, ForwardIterator1 last1,
          ForwardIterator2 result, UnaryOperation op);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class ForwardIterator, class BinaryOperation>
ForwardIterator
transform(ExecutionPolicy&& exec, // see 27.3.5
          ForwardIterator1 first1, ForwardIterator1 last1,
          ForwardIterator2 first2, ForwardIterator result,
          BinaryOperation binary_op);
namespace ranges {
template<class I, class O>
using unary_transform_result = in_out_result<I, O>;
template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
         copy_constructible F, class Proj = identity>
requires indirectly_writable<O, indirect_result_t<F&, projected<I, Proj>>>
                             constexpr unary_transform_result<I, O>
                             transform(I first1, S last1, O result, F op, Proj proj = {});
                             template<input_range R, weakly_incrementable O, copy_constructible F,
                                      class Proj = identity>
                             requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
                                     constexpr unary_transform_result<borrowed_iterator_t<R>, O>
                                     transform(R&& r, O result, F op, Proj proj = {});
                                     template<class I1, class I2, class O>
                                     using binary_transform_result = in_in_out_result<I1, I2, O>;
                                     template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
                                             weakly_incrementable O, copy_constructible F, class Proj1 = identity,
                                             class Proj2 = identity>
                                     requires indirectly_writable<O, indirect_result_t<F&, projected<I1, Proj1>,
                                             projected<I2, Proj2>>>
                                             constexpr binary_transform_result<I1, I2, O>
                                             transform(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                                                     F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
                                             template<input_range R1, input_range R2, weakly_incrementable O,
                                                     copy_constructible F, class Proj1 = identity, class Proj2 = identity>
                                             requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
                                                     projected<iterator_t<R2>, Proj2>>>
                                                     constexpr binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
                                                     transform(R1&& r1, R2&& r2, O result,
                                                             F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
}
// 27.7.5, replace
                                                     template<class ForwardIterator, class T>
                                                     constexpr void replace(ForwardIterator first, ForwardIterator last,
                                                             const T& old_value, const T& new_value);
                                             template<class ExecutionPolicy, class ForwardIterator, class T>
                                             void replace(ExecutionPolicy&& exec, // see 27.3.5
                                                     ForwardIterator first, ForwardIterator last,
                                                     const T& old_value, const T& new_value);
                                             template<class ForwardIterator, class Predicate, class T>
                                             constexpr void replace_if(ForwardIterator first, ForwardIterator last,
                                                     Predicate pred, const T& new_value);
                                             template<class ExecutionPolicy, class ForwardIterator, class Predicate, class T> void replace_if(ExecutionPolicy&& exec, // see 27.3.5
                                                     ForwardIterator first, ForwardIterator last,
                                                     Predicate pred, const T& new_value);
namespace ranges {
template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity>
requires indirectly_writable<I, const T2&> &&
indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
constexpr I
replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});
template<input_range R, class T1, class T2, class Proj = identity>
requires indirectly_writable<iterator_t<R>, const T2&> &&
indirect_binary_predicate<ranges::equal_to,
                          projected<iterator_t<R>, Proj>, const T1*>
constexpr borrowed_iterator_t<R>
replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});
template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
         indirect_unary_predicate<projected<I, Proj>> Pred>
requires indirectly_writable<I, const T&>
constexpr I replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
template<input_range R, class T, class Proj = identity,
         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
requires indirectly_writable<iterator_t<R>, const T&>
constexpr borrowed_iterator_t<R>
replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
}
template<class InputIterator, class OutputIterator, class T>
constexpr OutputIterator replace_copy(InputIterator first, InputIterator last,
                                      OutputIterator result,
                                      const T& old_value, const T& new_value);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
ForwardIterator2 replace_copy(ExecutionPolicy&& exec, // see 27.3.5
                              ForwardIterator1 first, ForwardIterator1 last,
                              ForwardIterator2 result,
                              const T& old_value, const T& new_value);
template<class InputIterator, class OutputIterator, class Predicate, class T>
constexpr OutputIterator replace_copy_if(InputIterator first, InputIterator last,
        OutputIterator result,
        Predicate pred, const T& new_value);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class Predicate, class T>
ForwardIterator2 replace_copy_if(ExecutionPolicy&& exec, // see 27.3.5
namespace ranges {
    template<class I, class O>
    ForwardIterator1 first, ForwardIterator1 last,
    ForwardIterator2 result,
    Predicate pred, const T& new_value);
    using replace_copy_result = in_out_result<I, O>;
    template<input_iterator I, sentinel_for<I> S, class T1, class T2,
             output_iterator<const T2&> O, class Proj = identity>
    requires indirectly_copyable<I, O> &&
    indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
    constexpr replace_copy_result<I, O>
    replace_copy(I first, S last, O result, const T1& old_value, const T2& new_value,
    Proj proj = {});
    template<input_range R, class T1, class T2, output_iterator<const T2&> O,
             class Proj = identity>
    requires indirectly_copyable<iterator_t<R>, O> &&
    indirect_binary_predicate<ranges::equal_to,
                              projected<iterator_t<R>, Proj>, const T1*>
    constexpr replace_copy_result<borrowed_iterator_t<R>, O>
    replace_copy(R&& r, O result, const T1& old_value, const T2& new_value,
    Proj proj = {});
    template<class I, class O>
    using replace_copy_if_result = in_out_result<I, O>;
    template<input_iterator I, sentinel_for<I> S, class T, output_iterator<const T&> O,
             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
    requires indirectly_copyable<I, O>
    constexpr replace_copy_if_result<I, O>
    replace_copy_if(I first, S last, O result, Pred pred, const T& new_value,
    Proj proj = {});
    template<input_range R, class T, output_iterator<const T&> O, class Proj = identity,
             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
    requires indirectly_copyable<iterator_t<R>, O>
    constexpr replace_copy_if_result<borrowed_iterator_t<R>, O>
    replace_copy_if(R&& r, O result, Pred pred, const T& new_value,
    Proj proj = {});
}
// 27.7.6, fill
template<class ForwardIterator, class T>
constexpr void fill(ForwardIterator first, ForwardIterator last, const T& value);
template<class ExecutionPolicy, class ForwardIterator, class T>
void fill(ExecutionPolicy&& exec, // see 27.3.5
          ForwardIterator first, ForwardIterator last, const T& value);
template<class OutputIterator, class Size, class T>
constexpr OutputIterator fill_n(OutputIterator first, Size n, const T& value);
template<class ExecutionPolicy, class ForwardIterator,
         class Size, class T>
ForwardIterator fill_n(ExecutionPolicy&& exec, // see 27.3.5
                       ForwardIterator first, Size n, const T& value);
namespace ranges {
    template<class T, output_iterator<const T&> O, sentinel_for<O> S>
    constexpr O fill(O first, S last, const T& value);
    template<class T, output_range<const T&> R>
    constexpr borrowed_iterator_t<R> fill(R&& r, const T& value);
    template<class T, output_iterator<const T&> O>
    constexpr O fill_n(O first, iter_difference_t<O> n, const T& value);
                      }
// 27.7.7, generate
template<class ForwardIterator, class Generator>
constexpr void generate(ForwardIterator first, ForwardIterator last,
                        Generator gen);
template<class ExecutionPolicy, class ForwardIterator, class Generator> void generate(ExecutionPolicy&& exec, // see 27.3.5
        ForwardIterator first, ForwardIterator last,
        Generator gen);
template<class OutputIterator, class Size, class Generator>
constexpr OutputIterator generate_n(OutputIterator first, Size n, Generator gen);
template<class ExecutionPolicy, class ForwardIterator, class Size, class Generator>
ForwardIterator generate_n(ExecutionPolicy&& exec, // see 27.3.5
                           ForwardIterator first, Size n, Generator gen);
namespace ranges {
    template<input_or_output_iterator O, sentinel_for<O> S, copy_constructible F>
    requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
    constexpr O generate(O first, S last, F gen);
    template<class R, copy_constructible F>
    requires invocable<F&> && output_range<R, invoke_result_t<F&>>
    constexpr borrowed_iterator_t<R> generate(R&& r, F gen);
    template<input_or_output_iterator O, copy_constructible F>
    requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
    constexpr O generate_n(O first, iter_difference_t<O> n, F gen);
                          }
// 27.7.8, remove
template<class ForwardIterator, class T>
constexpr ForwardIterator remove(ForwardIterator first, ForwardIterator last,
                                 const T& value);
template<class ExecutionPolicy, class ForwardIterator, class T> ForwardIterator remove(ExecutionPolicy&& exec, // see 27.3.5
        ForwardIterator first, ForwardIterator last,
        const T& value);
template<class ForwardIterator, class Predicate>
constexpr ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
                                    Predicate pred);
template<class ExecutionPolicy, class ForwardIterator, class Predicate> ForwardIterator remove_if(ExecutionPolicy&& exec, // see 27.3.5
        ForwardIterator first, ForwardIterator last,
        Predicate pred);
namespace ranges {
    template<permutable I, sentinel_for<I> S, class T, class Proj = identity>
    requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
    constexpr subrange<I> remove(I first, S last, const T& value, Proj proj = {});
    template<forward_range R, class T, class Proj = identity>
    requires permutable<iterator_t<R>> &&
    indirect_binary_predicate<ranges::equal_to,
                              projected<iterator_t<R>, Proj>, const T*>
    constexpr borrowed_subrange_t<R>
    remove(R&& r, const T& value, Proj proj = {});
    template<permutable I, sentinel_for<I> S, class Proj = identity,
             indirect_unary_predicate<projected<I, Proj>> Pred>
    constexpr subrange<I> remove_if(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>
    remove_if(R&& r, Pred pred, Proj proj = {});
                                 }
template<class InputIterator, class OutputIterator, class T>
constexpr OutputIterator
remove_copy(InputIterator first, InputIterator last,
            OutputIterator result, const T& value);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class T>
ForwardIterator2
remove_copy(ExecutionPolicy&& exec, // see 27.3.5
            ForwardIterator1 first, ForwardIterator1 last,
            ForwardIterator2 result, const T& value);
template<class InputIterator, class OutputIterator, class Predicate>
constexpr OutputIterator
remove_copy_if(InputIterator first, InputIterator last,
               OutputIterator result, Predicate pred);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class Predicate>
ForwardIterator2
remove_copy_if(ExecutionPolicy&& exec, // see 27.3.5
               ForwardIterator1 first, ForwardIterator1 last,
               ForwardIterator2 result, Predicate pred);
namespace ranges {
    template<class I, class O>
    using remove_copy_result = in_out_result<I, O>;
    template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class T,
             class Proj = identity>
    requires indirectly_copyable<I, O> &&
    indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
    constexpr remove_copy_result<I, O>
    remove_copy(I first, S last, O result, const T& value, Proj proj = {});
    template<input_range R, weakly_incrementable O, class T, class Proj = identity>
    requires indirectly_copyable<iterator_t<R>, O> &&
    indirect_binary_predicate<ranges::equal_to,
                              projected<iterator_t<R>, Proj>, const T*>
    constexpr remove_copy_result<borrowed_iterator_t<R>, O>
    remove_copy(R&& r, O result, const T& value, Proj proj = {});
    template<class I, class O>
    using remove_copy_if_result = in_out_result<I, O>;
    template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
    requires indirectly_copyable<I, O>
    constexpr remove_copy_if_result<I, O>
    remove_copy_if(I first, S last, O result, Pred pred, Proj proj = {});
    template<input_range R, weakly_incrementable O, class Proj = identity,
             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
    requires indirectly_copyable<iterator_t<R>, O>
    constexpr remove_copy_if_result<borrowed_iterator_t<R>, O>
    remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});
                                                       }
// 27.7.9, unique
template<class ForwardIterator>
constexpr ForwardIterator unique(ForwardIterator first, ForwardIterator last);
template<class ForwardIterator, class BinaryPredicate>
constexpr ForwardIterator unique(ForwardIterator first, ForwardIterator last,
                                 BinaryPredicate pred);
template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator unique(ExecutionPolicy&& exec, // see 27.3.5
                       ForwardIterator first, ForwardIterator last);
template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>
ForwardIterator unique(ExecutionPolicy&& exec, // see 27.3.5
                       ForwardIterator first, ForwardIterator last,
                       BinaryPredicate pred);
namespace ranges {
    template<permutable I, sentinel_for<I> S, class Proj = identity,
             indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
    constexpr subrange<I> unique(I first, S last, C comp = {}, Proj proj = {});
    template<forward_range R, class Proj = identity,
             indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
    requires permutable<iterator_t<R>>
    constexpr borrowed_subrange_t<R>
    unique(R&& r, C comp = {}, Proj proj = {});
                                 }
template<class InputIterator, class OutputIterator>
constexpr OutputIterator
unique_copy(InputIterator first, InputIterator last,
            OutputIterator result);
template<class InputIterator, class OutputIterator, class BinaryPredicate>
constexpr OutputIterator
unique_copy(InputIterator first, InputIterator last,
            OutputIterator result, BinaryPredicate pred);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2
unique_copy(ExecutionPolicy&& exec, // see 27.3.5
            ForwardIterator1 first, ForwardIterator1 last,
            ForwardIterator2 result);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class BinaryPredicate>
ForwardIterator2
unique_copy(ExecutionPolicy&& exec, // see 27.3.5
            ForwardIterator1 first, ForwardIterator1 last,
            ForwardIterator2 result, BinaryPredicate pred);
namespace ranges {
    template<class I, class O>
    using unique_copy_result = in_out_result<I, O>;
    template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
             indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
    requires indirectly_copyable<I, O> &&
    (forward_iterator<I> ||
     (input_iterator<O> && same_as<iter_value_t<I>, iter_value_t<O>>) ||
     indirectly_copyable_storable<I, O>)
    constexpr unique_copy_result<I, O>
    unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});
    template<input_range R, weakly_incrementable O, class Proj = identity,
             indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
    requires indirectly_copyable<iterator_t<R>, O> &&
    (forward_iterator<iterator_t<R>> ||
     (input_iterator<O> && same_as<range_value_t<R>, iter_value_t<O>>) ||
     indirectly_copyable_storable<iterator_t<R>, O>)
    constexpr unique_copy_result<borrowed_iterator_t<R>, O>
    unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
                                                    }
// 27.7.10, reverse
template<class BidirectionalIterator>
constexpr void reverse(BidirectionalIterator first, BidirectionalIterator last);
template<class ExecutionPolicy, class BidirectionalIterator>
void reverse(ExecutionPolicy&& exec, // see 27.3.5
             BidirectionalIterator first, BidirectionalIterator last);
namespace ranges {
    template<bidirectional_iterator I, sentinel_for<I> S>
    requires permutable<I>
    constexpr I reverse(I first, S last);
    template<bidirectional_range R>
    requires permutable<iterator_t<R>>
    constexpr borrowed_iterator_t<R> reverse(R&& r);
                                 }
template<class BidirectionalIterator, class OutputIterator>
constexpr OutputIterator
reverse_copy(BidirectionalIterator first, BidirectionalIterator last,
             OutputIterator result);
template<class ExecutionPolicy, class BidirectionalIterator, class ForwardIterator>
ForwardIterator
reverse_copy(ExecutionPolicy&& exec, // see 27.3.5
             BidirectionalIterator first, BidirectionalIterator last, ForwardIterator result);
namespace ranges {
    template<class I, class O>
    using reverse_copy_result = in_out_result<I, O>;
    template<bidirectional_iterator I, sentinel_for<I> S, weakly_incrementable O>
    requires indirectly_copyable<I, O>
    constexpr reverse_copy_result<I, O>
    reverse_copy(I first, S last, O result);
    template<bidirectional_range R, weakly_incrementable O>
    requires indirectly_copyable<iterator_t<R>, O>
    constexpr reverse_copy_result<borrowed_iterator_t<R>, O>
    reverse_copy(R&& r, O result);
                                                     }
// 27.7.11, rotate
template<class ForwardIterator>
constexpr ForwardIterator rotate(ForwardIterator first,
                                 ForwardIterator middle,
                                 ForwardIterator last);
template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator rotate(ExecutionPolicy&& exec,
                       ForwardIterator first,
                       ForwardIterator middle,
                       ForwardIterator last);
namespace ranges {
    template<permutable I, sentinel_for<I> S>
    constexpr subrange<I> rotate(I first, I middle, S last);
    template<forward_range R>
    requires permutable<iterator_t<R>>
// see 27.3.5
    constexpr borrowed_subrange_t<R> rotate(R&& r, iterator_t<R> middle);
                                           }
template<class ForwardIterator, class OutputIterator>
constexpr OutputIterator
rotate_copy(ForwardIterator first, ForwardIterator middle,
            ForwardIterator last, OutputIterator result);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2
rotate_copy(ExecutionPolicy&& exec, // see 27.3.5
            ForwardIterator1 first, ForwardIterator1 middle, ForwardIterator1 last, ForwardIterator2 result);
namespace ranges {
    template<class I, class O>
    using rotate_copy_result = in_out_result<I, O>;
    template<forward_iterator I, sentinel_for<I> S, weakly_incrementable O>
    requires indirectly_copyable<I, O>
    constexpr rotate_copy_result<I, O>
    rotate_copy(I first, I middle, S last, O result);
    template<forward_range R, weakly_incrementable O>
    requires indirectly_copyable<iterator_t<R>, O>
    constexpr rotate_copy_result<borrowed_iterator_t<R>, O>
    rotate_copy(R&& r, iterator_t<R> middle, O result);
               }
// 27.7.12, sample
template<class PopulationIterator, class SampleIterator,
         class Distance, class UniformRandomBitGenerator>
SampleIterator sample(PopulationIterator first, PopulationIterator last,
                      SampleIterator out, Distance n,
                      UniformRandomBitGenerator&& g);
namespace ranges {
    template<input_iterator I, sentinel_for<I> S,
             weakly_incrementable O, class Gen>
    requires (forward_iterator<I> || random_access_iterator<O>) &&
    indirectly_copyable<I, O> &&
    uniform_random_bit_generator<remove_reference_t<Gen>>
    O sample(I first, S last, O out, iter_difference_t<I> n, Gen&& g);
    template<input_range R, weakly_incrementable O, class Gen>
    requires (forward_range<R> || random_access_iterator<O>) &&
    indirectly_copyable<iterator_t<R>, O> &&
    uniform_random_bit_generator<remove_reference_t<Gen>>
    O sample(R&& r, O out, range_difference_t<R> n, Gen&& g);
            }
// 27.7.13, shuffle
template<class RandomAccessIterator, class UniformRandomBitGenerator>
void shuffle(RandomAccessIterator first,
             RandomAccessIterator last,
             UniformRandomBitGenerator&& g);
namespace ranges {
    template<random_access_iterator I, sentinel_for<I> S, class Gen>
    requires permutable<I> &&
    uniform_random_bit_generator<remove_reference_t<Gen>>
    I shuffle(I first, S last, Gen&& g);
    template<random_access_range R, class Gen>
    requires permutable<iterator_t<R>> &&
    uniform_random_bit_generator<remove_reference_t<Gen>>
    borrowed_iterator_t<R> shuffle(R&& r, Gen&& g);
                       }
// 27.7.14, shift
template<class ForwardIterator>
constexpr ForwardIterator
shift_left(ForwardIterator first, ForwardIterator last,
           typename iterator_traits<ForwardIterator>::difference_type n);
template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator
shift_left(ExecutionPolicy&& exec, // see 27.3.5
           ForwardIterator first, ForwardIterator last,
           typename iterator_traits<ForwardIterator>::difference_type n);
namespace ranges {
    template<permutable I, sentinel_for<I> S>
    constexpr subrange<I> shift_left(I first, S last, iter_difference_t<I> n);
    template<forward_range R>
    requires permutable<iterator_t<R>>
    constexpr borrowed_subrange_t<R> shift_left(R&& r, range_difference_t<R> n);
                                               }
template<class ForwardIterator>
constexpr ForwardIterator
shift_right(ForwardIterator first, ForwardIterator last,
            typename iterator_traits<ForwardIterator>::difference_type n);
template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator
shift_right(ExecutionPolicy&& exec, // see 27.3.5
            ForwardIterator first, ForwardIterator last,
            typename iterator_traits<ForwardIterator>::difference_type n);
namespace ranges {
    template<permutable I, sentinel_for<I> S>
    constexpr subrange<I> shift_right(I first, S last, iter_difference_t<I> n);
    template<forward_range R>
    requires permutable<iterator_t<R>>
    constexpr borrowed_subrange_t<R> shift_right(R&& r, range_difference_t<R> n);
                                                }
// 27.8, sorting and related operations
// 27.8.2, sorting
template<class RandomAccessIterator>
constexpr void sort(RandomAccessIterator first, RandomAccessIterator last);
template<class RandomAccessIterator, class Compare>
constexpr void sort(RandomAccessIterator first, RandomAccessIterator last,
                    Compare comp);
template<class ExecutionPolicy, class RandomAccessIterator>
void sort(ExecutionPolicy&& exec, // see 27.3.5
          RandomAccessIterator first, RandomAccessIterator last);
template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
void sort(ExecutionPolicy&& exec, // see 27.3.5
          RandomAccessIterator first, RandomAccessIterator last, Compare comp);
namespace ranges {
    template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
             class Proj = identity>
    requires sortable<I, Comp, Proj>
    constexpr I
    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>
    constexpr borrowed_iterator_t<R>
    sort(R&& r, Comp comp = {}, Proj proj = {});
                                 }
template<class RandomAccessIterator>
void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
template<class RandomAccessIterator, class Compare>
void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
                 Compare comp);
template<class ExecutionPolicy, class RandomAccessIterator>
void stable_sort(ExecutionPolicy&& exec, // see 27.3.5
                 RandomAccessIterator first, RandomAccessIterator last);
template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
void stable_sort(ExecutionPolicy&& exec, // see 27.3.5
                 RandomAccessIterator first, RandomAccessIterator last,
                 Compare comp);
namespace ranges {
    template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
             class Proj = identity>
    requires sortable<I, Comp, Proj>
    I 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>
    stable_sort(R&& r, Comp comp = {}, Proj proj = {});
                       }
template<class RandomAccessIterator>
constexpr void partial_sort(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>
void partial_sort(ExecutionPolicy&& exec, // see 27.3.5
                  RandomAccessIterator first, RandomAccessIterator middle,
                  RandomAccessIterator last);
template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
void partial_sort(ExecutionPolicy&& exec, // see 27.3.5
                  RandomAccessIterator first, RandomAccessIterator middle,
}
RandomAccessIterator last, Compare comp);
namespace ranges {
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         class Proj = identity>
requires sortable<I, Comp, Proj>
constexpr I
partial_sort(I first, I middle, 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>
partial_sort(R&& r, iterator_t<R> middle, Comp comp = {},
             Proj proj = {});
}
template<class InputIterator, class RandomAccessIterator>
constexpr RandomAccessIterator
partial_sort_copy(InputIterator first, InputIterator 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>
RandomAccessIterator
partial_sort_copy(ExecutionPolicy&& exec, // see 27.3.5
                  ForwardIterator first, ForwardIterator last,
                  RandomAccessIterator result_first,
                  RandomAccessIterator result_last);
template<class ExecutionPolicy, class ForwardIterator, class RandomAccessIterator,
         class Compare>
RandomAccessIterator
partial_sort_copy(ExecutionPolicy&& exec, // see 27.3.5
                  ForwardIterator first, ForwardIterator last,
                  RandomAccessIterator result_first,
                  RandomAccessIterator result_last,
                  Compare comp);
namespace ranges {
    template<class I, class O>
    using partial_sort_copy_result = in_out_result<I, O>;
    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 partial_sort_copy_result<I1, I2>
    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,
             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 partial_sort_copy_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
    partial_sort_copy(R1&& r, R2&& result_r, Comp comp = {},
                      Proj1 proj1 = {}, Proj2 proj2 = {});
    template<class ForwardIterator>
    constexpr bool is_sorted(ForwardIterator first, ForwardIterator last);
    template<class ForwardIterator, class Compare>
    constexpr bool is_sorted(ForwardIterator first, ForwardIterator last,
                             Compare comp);
    template<class ExecutionPolicy, class ForwardIterator>
    bool is_sorted(ExecutionPolicy&& exec, // see 27.3.5
                   ForwardIterator first, ForwardIterator last);
    template<class ExecutionPolicy, class ForwardIterator, class Compare> bool is_sorted(ExecutionPolicy&& exec, // see 27.3.5
            ForwardIterator first, ForwardIterator last,
            Compare comp);
    namespace ranges {
    template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
    constexpr bool 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 is_sorted(R&& r, Comp comp = {}, Proj proj = {});
    }
    template<class ForwardIterator>
    constexpr ForwardIterator
    is_sorted_until(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>
    ForwardIterator
    is_sorted_until(ExecutionPolicy&& exec, // see 27.3.5
                    ForwardIterator first, ForwardIterator last);
    template<class ExecutionPolicy, class ForwardIterator, class Compare>
    ForwardIterator
    is_sorted_until(ExecutionPolicy&& exec, // see 27.3.5
                    ForwardIterator first, ForwardIterator last,
                    Compare comp);
    namespace ranges {
    template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
    constexpr I 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>
    is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
    }
// 27.8.3, Nth element
    template<class RandomAccessIterator>
    constexpr void nth_element(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>
    void nth_element(ExecutionPolicy&& exec, // see 27.3.5
                     RandomAccessIterator first, RandomAccessIterator nth,
                     RandomAccessIterator last);
    template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
    void nth_element(ExecutionPolicy&& exec, // see 27.3.5
                     RandomAccessIterator first, RandomAccessIterator nth,
                     RandomAccessIterator last, Compare comp);
    namespace ranges {
    template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
             class Proj = identity>
    requires sortable<I, Comp, Proj>
    constexpr I
    nth_element(I first, I nth, 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>
    nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
    }
// 27.8.4, binary search
    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);
    namespace ranges {
    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 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 =
             ranges::less>
    constexpr borrowed_iterator_t<R>
    lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
    }
    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);
    namespace ranges {
    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 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>
    upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
    }
    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);
    namespace ranges {
    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>
    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 =
             ranges::less>
    constexpr borrowed_subrange_t<R>
    equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
    }
    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);
    namespace ranges {
    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 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 binary_search(R&& r, const T& value, Comp comp = {},
                                 Proj proj = {});
    }
// 27.8.5, 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, // see 27.3.5
                        ForwardIterator first, ForwardIterator last, Predicate pred);
    namespace ranges {
    template<input_iterator I, sentinel_for<I> S, class Proj = identity,
             indirect_unary_predicate<projected<I, Proj>> Pred>
    constexpr bool is_partitioned(I first, S last, Pred pred, Proj proj = {});
    template<input_range R, class Proj = identity,
             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
    constexpr bool is_partitioned(R&& r, Pred pred, Proj proj = {});
    }
    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, // see 27.3.5
                              ForwardIterator first,
                              ForwardIterator last,
                              Predicate pred);
    namespace ranges {
    template<permutable I, sentinel_for<I> S, class Proj = identity,
             indirect_unary_predicate<projected<I, Proj>> Pred>
    constexpr subrange<I>
    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>
    partition(R&& r, Pred pred, Proj proj = {});
    }
    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, // see // 27.3.5
                                           BidirectionalIterator first,
                                           BidirectionalIterator last,
                                           Predicate pred);
    namespace ranges {
    template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
             indirect_unary_predicate<projected<I, Proj>> Pred>
    requires permutable<I>
    subrange<I> stable_partition(I first, S last, Pred pred, Proj proj = {});
    template<bidirectional_range R, class Proj = identity,
             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
    requires permutable<iterator_t<R>>
    borrowed_subrange_t<R> stable_partition(R&& r, Pred pred, Proj proj = {});
    }
    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, // see 27.3.5
                   ForwardIterator first, ForwardIterator last,
                   ForwardIterator1 out_true, ForwardIterator2 out_false,
                   Predicate pred);
    namespace ranges {
    template<class I, class O1, class O2>
    using partition_copy_result = in_out_out_result<I, O1, O2>;
    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 partition_copy_result<I, O1, O2>
    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 partition_copy_result<borrowed_iterator_t<R>, O1, O2>
    }
    partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
    template<class ForwardIterator, class Predicate>
    constexpr ForwardIterator
    partition_point(ForwardIterator first, ForwardIterator last,
                    Predicate pred);
    namespace ranges {
    template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
             indirect_unary_predicate<projected<I, Proj>> Pred>
    constexpr I partition_point(I first, S last, Pred pred, Proj proj = {});
    template<forward_range R, class Proj = identity,
             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
    constexpr borrowed_iterator_t<R>
    partition_point(R&& r, Pred pred, Proj proj = {});
    }
// 27.8.6, merge
    template<class InputIterator1, class InputIterator2, class OutputIterator>
    constexpr OutputIterator
    merge(InputIterator1 first1, InputIterator1 last1,
          InputIterator2 first2, InputIterator2 last2,
          OutputIterator 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>
    ForwardIterator
    merge(ExecutionPolicy&& exec,
          ForwardIterator1 first1, ForwardIterator1 last1,
          ForwardIterator2 first2, ForwardIterator2 last2,
          ForwardIterator result);
// see 27.3.5
    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);
    namespace ranges {
    template<class I1, class I2, class O>
    using merge_result = in_in_out_result<I1, I2, O>;
// see 27.3.5
    }
    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 merge_result<I1, I2, O>
    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 merge_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
    merge(R1&& r1, R2&& r2, O result,
          Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
    template<class BidirectionalIterator>
    void inplace_merge(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>
    void inplace_merge(ExecutionPolicy&& exec, // see 27.3.5
                       BidirectionalIterator first,
                       BidirectionalIterator middle,
                       BidirectionalIterator last);
    template<class ExecutionPolicy, class BidirectionalIterator, class Compare>
    void inplace_merge(ExecutionPolicy&& exec, // see 27.3.5
                       BidirectionalIterator first,
                       BidirectionalIterator middle,
                       BidirectionalIterator last, Compare comp);
    namespace ranges {
    template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
             class Proj = identity>
    requires sortable<I, Comp, Proj>
    I inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});
    template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
    requires sortable<iterator_t<R>, Comp, Proj>
    borrowed_iterator_t<R>
    inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {},
                  Proj proj = {});
    }
// 27.8.7, set operations
    template<class InputIterator1, class InputIterator2>
    constexpr bool includes(InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, InputIterator2 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>
    bool includes(ExecutionPolicy&& exec, // see 27.3.5
                  ForwardIterator1 first1, ForwardIterator1 last1,
                  ForwardIterator2 first2, ForwardIterator2 last2);
    template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
             class Compare>
    bool includes(ExecutionPolicy&& exec, // see 27.3.5
                  ForwardIterator1 first1, ForwardIterator1 last1,
                  ForwardIterator2 first2, ForwardIterator2 last2,
                  Compare comp);
    namespace ranges {
    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 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 includes(R1&& r1, R2&& r2, Comp comp = {},
    }
    Proj1 proj1 = {}, Proj2 proj2 = {});
    template<class InputIterator1, class InputIterator2, class OutputIterator>
    constexpr OutputIterator
    set_union(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, InputIterator2 last2,
              OutputIterator 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>
    ForwardIterator
    set_union(ExecutionPolicy&& exec, // see 27.3.5
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              ForwardIterator result);
    template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
             class ForwardIterator, class Compare>
    ForwardIterator
    set_union(ExecutionPolicy&& exec, // see 27.3.5
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              ForwardIterator result, Compare comp);
    namespace ranges {
        template<class I1, class I2, class O>
        using set_union_result = in_in_out_result<I1, I2, O>;
    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 set_union_result<I1, I2, O>
    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 set_union_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
    set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
              Proj1 proj1 = {}, Proj2 proj2 = {});
                                                                           }
    template<class InputIterator1, class InputIterator2, class OutputIterator>
    constexpr OutputIterator
    set_intersection(InputIterator1 first1, InputIterator1 last1,
                     InputIterator2 first2, InputIterator2 last2,
                     OutputIterator 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>
    ForwardIterator
    set_intersection(ExecutionPolicy&& exec, // see 27.3.5
                     ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2,
                     ForwardIterator result);
    template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
             class ForwardIterator, class Compare>
    ForwardIterator
    set_intersection(ExecutionPolicy&& exec, // see 27.3.5
                     ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2,
                     ForwardIterator result, Compare comp);
    namespace ranges {
        template<class I1, class I2, class O>
        using set_intersection_result = in_in_out_result<I1, I2, O>;
    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 set_intersection_result<I1, I2, O>
    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>
    requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
    constexpr set_intersection_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
    set_intersection(R1&& r1, R2&& r2, O result,
                     Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
                                                                                  }
    template<class InputIterator1, class InputIterator2, class OutputIterator>
    constexpr OutputIterator
    set_difference(InputIterator1 first1, InputIterator1 last1,
                   InputIterator2 first2, InputIterator2 last2,
                   OutputIterator 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>
    ForwardIterator
    set_difference(ExecutionPolicy&& exec, // see 27.3.5
                   ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2,
                   ForwardIterator result);
    template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
             class ForwardIterator, class Compare>
    ForwardIterator
    set_difference(ExecutionPolicy&& exec, // see 27.3.5
                   ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2,
                   ForwardIterator result, Compare comp);
    namespace ranges {
        template<class I, class O>
        using set_difference_result = in_out_result<I, O>;
    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 set_difference_result<I1, O>
    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 set_difference_result<borrowed_iterator_t<R1>, O>
                                                       }
}
set_difference(R1&& r1, R2&& r2, O result,
               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
template<class InputIterator1, class InputIterator2, class OutputIterator>
constexpr OutputIterator
set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
                         InputIterator2 first2, InputIterator2 last2,
                         OutputIterator 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>
ForwardIterator
set_symmetric_difference(ExecutionPolicy&& exec, // see 27.3.5
                         ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2,
                         ForwardIterator result);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class ForwardIterator, class Compare>
ForwardIterator
set_symmetric_difference(ExecutionPolicy&& exec, // see 27.3.5
                         ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2,
                         ForwardIterator result, Compare comp);
namespace ranges {
    template<class I1, class I2, class O>
    using set_symmetric_difference_result = in_in_out_result<I1, I2, O>;
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 set_symmetric_difference_result<I1, I2, O>
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 set_symmetric_difference_result<borrowed_iterator_t<R1>,
        borrowed_iterator_t<R2>, O>
set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
                         Proj1 proj1 = {}, Proj2 proj2 = {});
// 27.8.8, heap operations
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);
namespace ranges {
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         class Proj = identity>
requires sortable<I, Comp, Proj>
constexpr I
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>
push_heap(R&& r, Comp comp = {}, Proj proj = {});
}
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);
namespace ranges {
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         class Proj = identity>
requires sortable<I, Comp, Proj>
constexpr I
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>
pop_heap(R&& r, Comp comp = {}, Proj proj = {});
}
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);
namespace ranges {
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         class Proj = identity>
requires sortable<I, Comp, Proj>
constexpr I
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>
make_heap(R&& r, Comp comp = {}, Proj proj = {});
}
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);
namespace ranges {
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         class Proj = identity>
requires sortable<I, Comp, Proj>
constexpr I
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>
sort_heap(R&& r, Comp comp = {}, Proj proj = {});
}
template<class RandomAccessIterator>
constexpr bool is_heap(RandomAccessIterator first, RandomAccessIterator last);
template<class RandomAccessIterator, class Compare>
constexpr bool is_heap(RandomAccessIterator first, RandomAccessIterator last,
                       Compare comp);
template<class ExecutionPolicy, class RandomAccessIterator>
bool is_heap(ExecutionPolicy&& exec, // see 27.3.5
             RandomAccessIterator first, RandomAccessIterator last);
template<class ExecutionPolicy, class RandomAccessIterator, class Compare> bool is_heap(ExecutionPolicy&& exec, // see 27.3.5
        RandomAccessIterator first, RandomAccessIterator last,
        Compare comp);
namespace ranges {
template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
constexpr bool 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 is_heap(R&& r, Comp comp = {}, Proj proj = {});
}
template<class RandomAccessIterator>
constexpr RandomAccessIterator
is_heap_until(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>
RandomAccessIterator
is_heap_until(ExecutionPolicy&& exec, // see 27.3.5
              RandomAccessIterator first, RandomAccessIterator last);
template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
RandomAccessIterator
is_heap_until(ExecutionPolicy&& exec, // see 27.3.5
              RandomAccessIterator first, RandomAccessIterator last,
              Compare comp);
namespace ranges {
template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
constexpr I is_heap_until(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 borrowed_iterator_t<R>
is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
}
// 27.8.9, minimum and maximum
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>
constexpr T min(initializer_list<T> t);
template<class T, class Compare>
constexpr T min(initializer_list<T> t, Compare comp);
namespace ranges {
template<class T, class Proj = identity,
         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
template<copyable T, class Proj = identity,
         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
constexpr T 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>
min(R&& r, Comp comp = {}, Proj proj = {});
}
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>
constexpr T max(initializer_list<T> t);
template<class T, class Compare>
constexpr T max(initializer_list<T> t, Compare comp);
namespace ranges {
template<class T, class Proj = identity,
         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
constexpr const T& max(const T& a, const T& b, Comp comp = {}, Proj proj = {});
template<copyable T, class Proj = identity,
         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
constexpr T max(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>
max(R&& r, Comp comp = {}, Proj proj = {});
}
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>
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);
namespace ranges {
template<class T>
using minmax_result = min_max_result<T>;
template<class T, class Proj = identity,
         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
constexpr minmax_result<const T&>
minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
template<copyable T, class Proj = identity,
         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
constexpr minmax_result<T>
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>
requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
constexpr minmax_result<range_value_t<R>>
minmax(R&& r, Comp comp = {}, Proj proj = {});
}
template<class ForwardIterator>
constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
template<class ForwardIterator, class Compare>
constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
                                      Compare comp);
template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator min_element(ExecutionPolicy&& exec, // see 27.3.5
                            ForwardIterator first, ForwardIterator last);
template<class ExecutionPolicy, class ForwardIterator, class Compare> ForwardIterator min_element(ExecutionPolicy&& exec, // see 27.3.5
        ForwardIterator first, ForwardIterator last,
        Compare comp);
namespace ranges {
template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
constexpr I 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>
min_element(R&& r, Comp comp = {}, Proj proj = {});
}
template<class ForwardIterator>
constexpr ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
template<class ForwardIterator, class Compare>
constexpr ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
                                      Compare comp);
template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator max_element(ExecutionPolicy&& exec, // see 27.3.5
                            ForwardIterator first, ForwardIterator last);
template<class ExecutionPolicy, class ForwardIterator, class Compare> ForwardIterator max_element(ExecutionPolicy&& exec, // see 27.3.5
        ForwardIterator first, ForwardIterator last,
        Compare comp);
namespace ranges {
template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
constexpr I max_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>
max_element(R&& r, Comp comp = {}, Proj proj = {});
}
template<class ForwardIterator>
constexpr pair<ForwardIterator, ForwardIterator>
minmax_element(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>
pair<ForwardIterator, ForwardIterator>
minmax_element(ExecutionPolicy&& exec, // see 27.3.5
               ForwardIterator first, ForwardIterator last);
template<class ExecutionPolicy, class ForwardIterator, class Compare>
pair<ForwardIterator, ForwardIterator>
minmax_element(ExecutionPolicy&& exec, // see 27.3.5
               ForwardIterator first, ForwardIterator last, Compare comp);
namespace ranges {
template<class I>
using minmax_element_result = min_max_result<I>;
template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
constexpr minmax_element_result<I>
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>
constexpr minmax_element_result<borrowed_iterator_t<R>>
}
minmax_element(R&& r, Comp comp = {}, Proj proj = {});
// 27.8.10, bounded value
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);
namespace ranges {
template<class T, class Proj = identity,
         indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
constexpr const T&
clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});
}
// 27.8.11, lexicographical comparison
template<class InputIterator1, class InputIterator2>
constexpr bool
lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, InputIterator2 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>
bool
lexicographical_compare(ExecutionPolicy&& exec, // see 27.3.5
                        ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2, ForwardIterator2 last2);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
         class Compare>
bool
lexicographical_compare(ExecutionPolicy&& exec, // see 27.3.5
                        ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2, ForwardIterator2 last2,
                        Compare comp);
namespace ranges {
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
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
lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
                        Proj1 proj1 = {}, Proj2 proj2 = {});
}
// 27.8.12, three-way comparison algorithms
template<class InputIterator1, class InputIterator2, class Cmp>
constexpr auto
lexicographical_compare_three_way(InputIterator1 b1, InputIterator1 e1,
                                  -> decltype(comp(*b1, *b2));
    InputIterator2 b2, InputIterator2 e2,
    Cmp comp)
    }
    }
Algorithm result types
// [algorithms.results]
template<class InputIterator1, class InputIterator2>
constexpr auto
lexicographical_compare_three_way(InputIterator1 b1, InputIterator1 e1,
                                  InputIterator2 b2, InputIterator2 e2);
// 27.8.13, permutations
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);
namespace ranges {
    template<class I>
    using next_permutation_result = in_found_result<I>;
    template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
             class Proj = identity>
    requires sortable<I, Comp, Proj>
    constexpr next_permutation_result<I>
    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 next_permutation_result<borrowed_iterator_t<R>>
    next_permutation(R&& r, Comp comp = {}, Proj proj = {});
}
template<class BidirectionalIterator>
constexpr bool prev_permutation(BidirectionalIterator first,
                                BidirectionalIterator last);
template<class BidirectionalIterator, class Compare>
constexpr bool prev_permutation(BidirectionalIterator first,
                                BidirectionalIterator last, Compare comp);
namespace ranges {
    template<class I>
    using prev_permutation_result = in_found_result<I>;
    template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
             class Proj = identity>
    requires sortable<I, Comp, Proj>
    constexpr prev_permutation_result<I>
    prev_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 prev_permutation_result<borrowed_iterator_t<R>>
    prev_permutation(R&& r, Comp comp = {}, Proj proj = {});
}
int main() {
    cout  <<  n4910 << endl;
    return EXIT_SUCCESS;
}
```

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

```ubuntu:bash
$ clang++ p1153.cpp -std=03 -o p1153l -I. -Wall
In file included from p1153.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 \
 ^
p1153.cpp:39:7: error: unknown type name 'constexpr'
      constexpr bool all_of(InputIterator first, InputIterator last, Predicate pred);
      ^
p1153.cpp:41:28: warning: rvalue references are a C++11 extension [-Wc++11-extensions]
bool all_of(ExecutionPolicy&& exec, // see 27.3.5 
                           ^
p1153.cpp:44:12: error: unknown type name 'input_iterator'
  template<input_iterator I, sentinel_for<I> S, class Proj = identity,
           ^
p1153.cpp:44:30: error: no template named 'sentinel_for'
  template<input_iterator I, sentinel_for<I> S, class Proj = identity,
                             ^
p1153.cpp:44:62: error: unknown type name 'identity'
  template<input_iterator I, sentinel_for<I> S, class Proj = identity,
                                                             ^
p1153.cpp:45:54: error: a space is required between consecutive right angle brackets (use '> >')
           indirect_unary_predicate<projected<I, Proj>> Pred>
                                                     ^~
                                                     > >
p1153.cpp:45:37: error: use of undeclared identifier 'projected'
           indirect_unary_predicate<projected<I, Proj>> Pred>
                                    ^
p1153.cpp:46:5: error: unknown type name 'constexpr'
    constexpr bool all_of(I first, S last, Pred pred, Proj proj = {});
    ^
p1153.cpp:46:27: error: unknown type name 'I'
    constexpr bool all_of(I first, S last, Pred pred, Proj proj = {});
                          ^
p1153.cpp:46:36: error: unknown type name 'S'
    constexpr bool all_of(I first, S last, Pred pred, Proj proj = {});
                                   ^
p1153.cpp:46:44: error: unknown type name 'Pred'
    constexpr bool all_of(I first, S last, Pred pred, Proj proj = {});
                                           ^
p1153.cpp:46:67: error: expected expression
    constexpr bool all_of(I first, S last, Pred pred, Proj proj = {});
                                                                  ^
p1153.cpp:47:12: error: unknown type name 'input_range'
  template<input_range R, class Proj = identity,
           ^
p1153.cpp:47:40: error: unknown type name 'identity'
  template<input_range R, class Proj = identity,
                                       ^
p1153.cpp:48:47: error: use of undeclared identifier 'iterator_t'
           indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
                                              ^
p1153.cpp:48:12: error: no template named 'indirect_unary_predicate'
           indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
           ^
p1153.cpp:49:60: error: expected '>'
    constexpr bool all_of(R&& r, Pred pred, Proj proj = {});
                                                           ^
p1153.cpp:48:36: note: to match this '<'
           indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
                                   ^
p1153.cpp:49:60: error: expected ',' or '>' in template-parameter-list
    constexpr bool all_of(R&& r, Pred pred, Proj proj = {});
                                                           ^
p1153.cpp:49:60: error: declaration does not declare anything
fatal error: too many errors emitted, stopping now [-ferror-limit=]
1 warning and 20 errors generated.
$ clang++ p1153.cpp -std=2b -o p1153l -I. -Wall
p1153.cpp:150:1: error: expected unqualified-id
}
^
p1153.cpp:151:13: error: unknown type name 'R'
find_if_not(R&& r, Pred pred, Proj proj = {});
            ^
p1153.cpp:151:20: error: unknown type name 'Pred'
find_if_not(R&& r, Pred pred, Proj proj = {});
                   ^
p1153.cpp:151:31: error: unknown type name 'Proj'
find_if_not(R&& r, Pred pred, Proj proj = {});
                              ^
p1153.cpp:151:1: error: C++ requires a type specifier for all declarations
find_if_not(R&& r, Pred pred, Proj proj = {});
^
p1153.cpp:250:1: error: expected expression
template<class InputIterator, class T>
^
p1153.cpp:251:3: error: expected identifier
  constexpr typename iterator_traits<InputIterator>::difference_type
  ^
p1153.cpp:251:52: error: no type named 'difference_type' in the global namespace; did you mean '_Bit_const_iterator::difference_type'?
  constexpr typename iterator_traits<InputIterator>::difference_type
                                                   ^~~~~~~~~~~~~~~~~
                                                   _Bit_const_iterator::difference_type
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/stl_iterator_base_types.h:134:26: note: '_Bit_const_iterator::difference_type' declared here
      typedef _Distance  difference_type;
                         ^
p1153.cpp:252:11: error: unknown type name 'InputIterator'
    count(InputIterator first, InputIterator last, const T& value);
          ^
p1153.cpp:252:32: error: unknown type name 'InputIterator'
    count(InputIterator first, InputIterator last, const T& value);
                               ^
p1153.cpp:252:58: error: unknown type name 'T'
    count(InputIterator first, InputIterator last, const T& value);
                                                         ^
p1153.cpp:263:53: error: use of undeclared identifier 'R'
                               projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
                                                    ^
p1153.cpp:263:62: error: expected unqualified-id
                               projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
                                                             ^
p1153.cpp:265:35: error: use of undeclared identifier 'R'
    constexpr borrowed_iterator_t<R>
                                  ^
p1153.cpp:266:1: error: expected unqualified-id
}
^
p1153.cpp:377:20: error: redefinition of 'equal' as different kind of symbol
    constexpr bool equal(I1 first1, S1 last1, I2 first2, S2 last2,
                   ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/ranges_algobase.h:159:31: note: previous definition is here
  inline constexpr __equal_fn equal{};
                              ^
p1153.cpp:383:20: error: redefinition of 'equal' as different kind of symbol
    constexpr bool equal(R1&& r1, R2&& r2, Pred pred = {},
                   ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/ranges_algobase.h:159:31: note: previous definition is here
  inline constexpr __equal_fn equal{};
                              ^
p1153.cpp:534:7: error: redefinition of 'copy' as different kind of symbol
      copy(I first, S last, O result);
      ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/ranges_algobase.h:321:30: note: previous definition is here
  inline constexpr __copy_fn copy{};
                             ^
p1153.cpp:538:7: error: redefinition of 'copy' as different kind of symbol
      copy(R&& r, O result);
      ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/ranges_algobase.h:321:30: note: previous definition is here
  inline constexpr __copy_fn copy{};
                             ^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
20 errors generated.

$ g++ p1153.cpp -std=03 -o p1153g -I. -Wall
In file included from /usr/local/include/c++/12.1.0/atomic:38,
                 from N4910.h:11,
                 from p1153.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 \
      |  ^~~~~
p1153.cpp:39:7: warning: identifier 'constexpr' is a keyword in C++11 [-Wc++11-compat]
   39 |       constexpr bool all_of(InputIterator first, InputIterator last, Predicate pred);
      |       ^~~~~~~~~
p1153.cpp:2038:4: warning: identifier 'decltype' is a keyword in C++11 [-Wc++11-compat]
 2038 | -> decltype(comp(*b1, *b2));
      |    ^~~~~~~~
p1153.cpp:39:7: error: 'constexpr' does not name a type
   39 |       constexpr bool all_of(InputIterator first, InputIterator last, Predicate pred);
      |       ^~~~~~~~~
p1153.cpp:39:7: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:41:28: error: expected ',' or '...' before '&&' token
   41 | bool all_of(ExecutionPolicy&& exec, // see 27.3.5
      |                            ^~
p1153.cpp:44:12: error: 'input_iterator' has not been declared
   44 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~
p1153.cpp:44:30: error: 'sentinel_for' has not been declared
   44 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1153.cpp:44:42: error: expected '>' before '<' token
   44 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                          ^
p1153.cpp:46:67: error: expected unqualified-id before '{' token
   46 |     constexpr bool all_of(I first, S last, Pred pred, Proj proj = {});
      |                                                                   ^
p1153.cpp:46:69: error: expected unqualified-id before ')' token
   46 |     constexpr bool all_of(I first, S last, Pred pred, Proj proj = {});
      |                                                                     ^
p1153.cpp:47:12: error: 'input_range' has not been declared
   47 |   template<input_range R, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:47:40: error: 'identity' does not name a type
   47 |   template<input_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1153.cpp:48:12: error: 'indirect_unary_predicate' has not been declared
   48 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:48:36: error: expected '>' before '<' token
   48 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                    ^
p1153.cpp:49:57: error: expected unqualified-id before '{' token
   49 |     constexpr bool all_of(R&& r, Pred pred, Proj proj = {});
      |                                                         ^
p1153.cpp:49:59: error: expected unqualified-id before ')' token
   49 |     constexpr bool all_of(R&& r, Pred pred, Proj proj = {});
      |                                                           ^
p1153.cpp:53:3: error: 'constexpr' does not name a type
   53 |   constexpr bool any_of(InputIterator first, InputIterator last, Predicate pred);
      |   ^~~~~~~~~
p1153.cpp:53:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:55:28: error: expected ',' or '...' before '&&' token
   55 | bool any_of(ExecutionPolicy&& exec, // see 27.3.5
      |                            ^~
p1153.cpp:58:12: error: 'input_iterator' has not been declared
   58 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~
p1153.cpp:58:30: error: 'sentinel_for' has not been declared
   58 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1153.cpp:58:42: error: expected '>' before '<' token
   58 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                          ^
p1153.cpp:60:67: error: expected unqualified-id before '{' token
   60 |     constexpr bool any_of(I first, S last, Pred pred, Proj proj = {});
      |                                                                   ^
p1153.cpp:60:69: error: expected unqualified-id before ')' token
   60 |     constexpr bool any_of(I first, S last, Pred pred, Proj proj = {});
      |                                                                     ^
p1153.cpp:61:12: error: 'input_range' has not been declared
   61 |   template<input_range R, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:61:40: error: 'identity' does not name a type
   61 |   template<input_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1153.cpp:62:12: error: 'indirect_unary_predicate' has not been declared
   62 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:62:36: error: expected '>' before '<' token
   62 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                    ^
p1153.cpp:63:57: error: expected unqualified-id before '{' token
   63 |     constexpr bool any_of(R&& r, Pred pred, Proj proj = {});
      |                                                         ^
p1153.cpp:63:59: error: expected unqualified-id before ')' token
   63 |     constexpr bool any_of(R&& r, Pred pred, Proj proj = {});
      |                                                           ^
p1153.cpp:67:3: error: 'constexpr' does not name a type
   67 |   constexpr bool none_of(InputIterator first, InputIterator last, Predicate pred);
      |   ^~~~~~~~~
p1153.cpp:67:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:69:29: error: expected ',' or '...' before '&&' token
   69 | bool none_of(ExecutionPolicy&& exec, // see 27.3.5
      |                             ^~
p1153.cpp:72:12: error: 'input_iterator' has not been declared
   72 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~
p1153.cpp:72:30: error: 'sentinel_for' has not been declared
   72 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1153.cpp:72:42: error: expected '>' before '<' token
   72 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                          ^
p1153.cpp:74:68: error: expected unqualified-id before '{' token
   74 |     constexpr bool none_of(I first, S last, Pred pred, Proj proj = {});
      |                                                                    ^
p1153.cpp:74:70: error: expected unqualified-id before ')' token
   74 |     constexpr bool none_of(I first, S last, Pred pred, Proj proj = {});
      |                                                                      ^
p1153.cpp:75:12: error: 'input_range' has not been declared
   75 |   template<input_range R, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:75:40: error: 'identity' does not name a type
   75 |   template<input_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1153.cpp:76:12: error: 'indirect_unary_predicate' has not been declared
   76 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:76:36: error: expected '>' before '<' token
   76 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                    ^
p1153.cpp:77:58: error: expected unqualified-id before '{' token
   77 |     constexpr bool none_of(R&& r, Pred pred, Proj proj = {});
      |                                                          ^
p1153.cpp:77:60: error: expected unqualified-id before ')' token
   77 |     constexpr bool none_of(R&& r, Pred pred, Proj proj = {});
      |                                                            ^
p1153.cpp:81:3: error: 'constexpr' does not name a type
   81 |   constexpr Function for_each(InputIterator first, InputIterator last, Function f);
      |   ^~~~~~~~~
p1153.cpp:81:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:83:30: error: expected ',' or '...' before '&&' token
   83 | void for_each(ExecutionPolicy&& exec, // see 27.3.5
      |                              ^~
p1153.cpp:87:5: error: expected unqualified-id before 'using'
   87 |     using for_each_result = in_fun_result<I, F>;
      |     ^~~~~
p1153.cpp:88:12: error: 'input_iterator' has not been declared
   88 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~
p1153.cpp:88:30: error: 'sentinel_for' has not been declared
   88 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1153.cpp:88:42: error: expected '>' before '<' token
   88 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                          ^
p1153.cpp:91:52: error: expected unqualified-id before '{' token
   91 |       for_each(I first, S last, Fun f, Proj proj = {});
      |                                                    ^
p1153.cpp:91:54: error: expected unqualified-id before ')' token
   91 |       for_each(I first, S last, Fun f, Proj proj = {});
      |                                                      ^
p1153.cpp:92:12: error: 'input_range' has not been declared
   92 |   template<input_range R, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:92:40: error: 'identity' does not name a type
   92 |   template<input_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1153.cpp:93:12: error: 'indirectly_unary_invocable' has not been declared
   93 |            indirectly_unary_invocable<projected<iterator_t<R>, Proj>> Fun>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:93:38: error: expected '>' before '<' token
   93 |            indirectly_unary_invocable<projected<iterator_t<R>, Proj>> Fun>
      |                                      ^
p1153.cpp:95:42: error: expected unqualified-id before '{' token
   95 |       for_each(R&& r, Fun f, Proj proj = {});
      |                                          ^
p1153.cpp:95:44: error: expected unqualified-id before ')' token
   95 |       for_each(R&& r, Fun f, Proj proj = {});
      |                                            ^
p1153.cpp:98:3: error: 'constexpr' does not name a type
   98 |   constexpr InputIterator for_each_n(InputIterator first, Size n, Function f);
      |   ^~~~~~~~~
p1153.cpp:98:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:99:126: error: expected ',' or '...' before '&&' token
   99 |  ForwardIterator, class Size, class Function> ForwardIterator for_each_n(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                         ^~

p1153.cpp:103:5: error: expected unqualified-id before 'using'
  103 |     using for_each_n_result = in_fun_result<I, F>;
      |     ^~~~~
p1153.cpp:104:12: error: 'input_iterator' has not been declared
  104 |   template<input_iterator I, class Proj = identity,
      |            ^~~~~~~~~~~~~~
p1153.cpp:104:43: error: 'identity' does not name a type
  104 |   template<input_iterator I, class Proj = identity,
      |                                           ^~~~~~~~
p1153.cpp:105:12: error: 'indirectly_unary_invocable' has not been declared
  105 |            indirectly_unary_invocable<projected<I, Proj>> Fun>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:105:38: error: expected '>' before '<' token
  105 |            indirectly_unary_invocable<projected<I, Proj>> Fun>
      |                                      ^
p1153.cpp:107:70: error: expected unqualified-id before '{' token
  107 |       for_each_n(I first, iter_difference_t<I> n, Fun f, Proj proj = {});
      |                                                                      ^
p1153.cpp:107:72: error: expected unqualified-id before ')' token
  107 |       for_each_n(I first, iter_difference_t<I> n, Fun f, Proj proj = {});
      |                                                                        ^
p1153.cpp:111:3: error: 'constexpr' does not name a type
  111 |   constexpr InputIterator find(InputIterator first, InputIterator last,
      |   ^~~~~~~~~
p1153.cpp:111:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:113:101: error: expected ',' or '...' before '&&' token
  113 | ss ExecutionPolicy, class ForwardIterator, class T> ForwardIterator find(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                         ^~

p1153.cpp:117:3: error: 'constexpr' does not name a type
  117 |   constexpr InputIterator find_if(InputIterator first, InputIterator last,
      |   ^~~~~~~~~
p1153.cpp:117:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:119:112: error: expected ',' or '...' before '&&' token
  119 | nPolicy, class ForwardIterator, class Predicate> ForwardIterator find_if(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                         ^~

p1153.cpp:123:3: error: 'constexpr' does not name a type
  123 |   constexpr InputIterator find_if_not(InputIterator first, InputIterator last,
      |   ^~~~~~~~~
p1153.cpp:123:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:125:116: error: expected ',' or '...' before '&&' token
  125 | icy, class ForwardIterator, class Predicate> ForwardIterator find_if_not(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                         ^~

p1153.cpp:129:12: error: 'input_iterator' has not been declared
  129 |   template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
      |            ^~~~~~~~~~~~~~
p1153.cpp:129:30: error: 'sentinel_for' has not been declared
  129 |   template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
      |                              ^~~~~~~~~~~~
p1153.cpp:129:42: error: expected '>' before '<' token
  129 |   template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
      |                                          ^
p1153.cpp:130:5: error: 'requires' does not name a type
  130 |     requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
      |     ^~~~~~~~
p1153.cpp:130:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:131:69: error: expected unqualified-id before ')' token
  131 |     constexpr I find(I first, S last, const T& value, Proj proj = {});
      |                                                                     ^
p1153.cpp:132:12: error: 'input_range' has not been declared
  132 |   template<input_range R, class T, class Proj = identity>
      |            ^~~~~~~~~~~
p1153.cpp:132:49: error: 'identity' does not name a type
  132 |   template<input_range R, class T, class Proj = identity>
      |                                                 ^~~~~~~~
p1153.cpp:133:5: error: 'requires' does not name a type
  133 |     requires indirect_binary_predicate<ranges::equal_to,
      |     ^~~~~~~~
p1153.cpp:133:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:136:49: error: expected unqualified-id before ')' token
  136 |       find(R&& r, const T& value, Proj proj = {});
      |                                                 ^
p1153.cpp:137:12: error: 'input_iterator' has not been declared
  137 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~
p1153.cpp:137:30: error: 'sentinel_for' has not been declared
  137 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1153.cpp:137:42: error: expected '>' before '<' token
  137 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                          ^
p1153.cpp:139:65: error: expected unqualified-id before '{' token
  139 |     constexpr I find_if(I first, S last, Pred pred, Proj proj = {});
      |                                                                 ^
p1153.cpp:139:67: error: expected unqualified-id before ')' token
  139 |     constexpr I find_if(I first, S last, Pred pred, Proj proj = {});
      |                                                                   ^
p1153.cpp:140:12: error: 'input_range' has not been declared
  140 |   template<input_range R, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:140:40: error: 'identity' does not name a type
  140 |   template<input_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1153.cpp:141:12: error: 'indirect_unary_predicate' has not been declared
  141 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:141:36: error: expected '>' before '<' token
  141 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                    ^
p1153.cpp:143:45: error: expected unqualified-id before '{' token
  143 |       find_if(R&& r, Pred pred, Proj proj = {});
      |                                             ^
p1153.cpp:143:47: error: expected unqualified-id before ')' token
  143 |       find_if(R&& r, Pred pred, Proj proj = {});
      |                                               ^
p1153.cpp:144:12: error: 'input_iterator' has not been declared
  144 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~
p1153.cpp:144:30: error: 'sentinel_for' has not been declared
  144 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1153.cpp:144:42: error: expected '>' before '<' token
  144 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                          ^
p1153.cpp:146:69: error: expected unqualified-id before '{' token
  146 |     constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {});
      |                                                                     ^
p1153.cpp:146:71: error: expected unqualified-id before ')' token
  146 |     constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {});
      |                                                                       ^
p1153.cpp:147:12: error: 'input_range' has not been declared
  147 |   template<input_range R, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:147:40: error: 'identity' does not name a type
  147 |   template<input_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1153.cpp:148:12: error: 'indirect_unary_predicate' has not been declared
  148 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:148:36: error: expected '>' before '<' token
  148 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                    ^
p1153.cpp:150:1: error: expected unqualified-id before '}' token
  150 | }
      | ^
p1153.cpp:151:12: error: expected constructor, destructor, or type conversion before '(' token
  151 | find_if_not(R&& r, Pred pred, Proj proj = {});
      |            ^
p1153.cpp:151:45: error: expected unqualified-id before ')' token
  151 | find_if_not(R&& r, Pred pred, Proj proj = {});
      |                                             ^
p1153.cpp:154:3: error: 'constexpr' does not name a type
  154 |   constexpr ForwardIterator1
      |   ^~~~~~~~~
p1153.cpp:154:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:158:3: error: 'constexpr' does not name a type
  158 |   constexpr ForwardIterator1
      |   ^~~~~~~~~
p1153.cpp:158:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:164:25: error: expected ',' or '...' before '&&' token
  164 | find_end(ExecutionPolicy&& exec, // see 27.3.5
      |                         ^~
p1153.cpp:170:27: error: expected ',' or '...' before '&&' token
  170 |   find_end(ExecutionPolicy&& exec,
      |                           ^~
p1153.cpp:176:12: error: 'forward_iterator' has not been declared
  176 |   template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:176:33: error: 'sentinel_for' has not been declared
  176 |   template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
      |                                 ^~~~~~~~~~~~
p1153.cpp:176:45: error: expected '>' before '<' token
  176 |   template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
      |                                             ^
p1153.cpp:178:5: error: 'requires' does not name a type
  178 |     requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:178:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:180:72: error: expected unqualified-id before ',' token
  180 |       find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
      |                                                                        ^
p1153.cpp:181:22: error: expected constructor, destructor, or type conversion before 'proj1'
  181 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                      ^~~~~
p1153.cpp:181:32: error: expected unqualified-id before ',' token
  181 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                ^
p1153.cpp:181:40: error: expected constructor, destructor, or type conversion before 'proj2'
  181 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                        ^~~~~
p1153.cpp:181:50: error: expected unqualified-id before ')' token
  181 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                  ^
p1153.cpp:182:12: error: 'forward_range' has not been declared
  182 |   template<forward_range R1, forward_range R2,
      |            ^~~~~~~~~~~~~
p1153.cpp:182:30: error: 'forward_range' has not been declared
  182 |   template<forward_range R1, forward_range R2,
      |                              ^~~~~~~~~~~~~
p1153.cpp:183:33: error: 'equal_to' in namespace 'std::ranges' does not name a type
  183 |            class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
      |                                 ^~~~~~~~
p1153.cpp:183:57: error: 'identity' does not name a type
  183 |            class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
      |                                                         ^~~~~~~~
p1153.cpp:183:81: error: 'identity' does not name a type
  183 |            class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
      |                                                                                 ^~~~~~~~
p1153.cpp:184:5: error: 'requires' does not name a type
  184 |     requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:184:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:186:48: error: expected unqualified-id before ',' token
  186 |       find_end(R1&& r1, R2&& r2, Pred pred = {},
      |                                                ^
p1153.cpp:187:22: error: expected constructor, destructor, or type conversion before 'proj1'
  187 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                      ^~~~~
p1153.cpp:187:32: error: expected unqualified-id before ',' token
  187 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                ^
p1153.cpp:187:40: error: expected constructor, destructor, or type conversion before 'proj2'
  187 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                        ^~~~~
p1153.cpp:187:50: error: expected unqualified-id before ')' token
  187 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                  ^
p1153.cpp:191:3: error: 'constexpr' does not name a type
  191 |   constexpr InputIterator
      |   ^~~~~~~~~
p1153.cpp:191:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:195:3: error: 'constexpr' does not name a type
  195 |   constexpr InputIterator
      |   ^~~~~~~~~
p1153.cpp:195:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:201:30: error: expected ',' or '...' before '&&' token
  201 | find_first_of(ExecutionPolicy&& exec, // see 27.3.5
      |                              ^~
p1153.cpp:207:30: error: expected ',' or '...' before '&&' token
  207 | find_first_of(ExecutionPolicy&& exec, // see 27.3.5
      |                              ^~
p1153.cpp:212:12: error: 'input_iterator' has not been declared
  212 |   template<input_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
      |            ^~~~~~~~~~~~~~
p1153.cpp:212:31: error: 'sentinel_for' has not been declared
  212 |   template<input_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
      |                               ^~~~~~~~~~~~
p1153.cpp:212:43: error: expected '>' before '<' token
  212 |   template<input_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
      |                                           ^
p1153.cpp:214:5: error: 'requires' does not name a type
  214 |     requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:214:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:215:88: error: expected unqualified-id before ',' token
  215 |     constexpr I1 find_first_of(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
      |                                                                                        ^
p1153.cpp:216:38: error: expected constructor, destructor, or type conversion before 'proj1'
  216 |                                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                      ^~~~~
p1153.cpp:216:48: error: expected unqualified-id before ',' token
  216 |                                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                ^
p1153.cpp:216:56: error: expected constructor, destructor, or type conversion before 'proj2'
  216 |                                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                        ^~~~~
p1153.cpp:216:66: error: expected unqualified-id before ')' token
  216 |                                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                  ^
p1153.cpp:217:12: error: 'input_range' has not been declared
  217 |   template<input_range R1, forward_range R2,
      |            ^~~~~~~~~~~
p1153.cpp:217:28: error: 'forward_range' has not been declared
  217 |   template<input_range R1, forward_range R2,
      |                            ^~~~~~~~~~~~~
p1153.cpp:218:33: error: 'equal_to' in namespace 'std::ranges' does not name a type
  218 |            class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
      |                                 ^~~~~~~~
p1153.cpp:218:57: error: 'identity' does not name a type
  218 |            class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
      |                                                         ^~~~~~~~
p1153.cpp:218:81: error: 'identity' does not name a type
  218 |            class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
      |                                                                                 ^~~~~~~~
p1153.cpp:219:5: error: 'requires' does not name a type
  219 |     requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:219:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:221:53: error: expected unqualified-id before ',' token
  221 |       find_first_of(R1&& r1, R2&& r2, Pred pred = {},
      |                                                     ^
p1153.cpp:222:27: error: expected constructor, destructor, or type conversion before 'proj1'
  222 |                     Proj1 proj1 = {}, Proj2 proj2 = {});
      |                           ^~~~~
p1153.cpp:222:37: error: expected unqualified-id before ',' token
  222 |                     Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                     ^
p1153.cpp:222:45: error: expected constructor, destructor, or type conversion before 'proj2'
  222 |                     Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                             ^~~~~
p1153.cpp:222:55: error: expected unqualified-id before ')' token
  222 |                     Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                       ^
p1153.cpp:226:3: error: 'constexpr' does not name a type
  226 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1153.cpp:226:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:229:3: error: 'constexpr' does not name a type
  229 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1153.cpp:229:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:234:30: error: expected ',' or '...' before '&&' token
  234 | adjacent_find(ExecutionPolicy&& exec, // see 27.3.5
      |                              ^~
p1153.cpp:238:30: error: expected ',' or '...' before '&&' token
  238 | adjacent_find(ExecutionPolicy&& exec, // see 27.3.5
      |                              ^~
p1153.cpp:242:12: error: 'forward_iterator' has not been declared
  242 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:242:32: error: 'sentinel_for' has not been declared
  242 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                ^~~~~~~~~~~~
p1153.cpp:242:44: error: expected '>' before '<' token
  242 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                            ^
p1153.cpp:245:60: error: expected unqualified-id before '{' token
  245 |     constexpr I adjacent_find(I first, S last, Pred pred = {},
      |                                                            ^
p1153.cpp:245:62: error: expected unqualified-id before ',' token
  245 |     constexpr I adjacent_find(I first, S last, Pred pred = {},
      |                                                              ^
p1153.cpp:246:36: error: expected constructor, destructor, or type conversion before 'proj'
  246 |                               Proj proj = {});
      |                                    ^~~~
p1153.cpp:246:45: error: expected unqualified-id before ')' token
  246 |                               Proj proj = {});
      |                                             ^
p1153.cpp:247:12: error: 'forward_range' has not been declared
  247 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:247:42: error: 'identity' does not name a type
  247 |   template<forward_range R, class Proj = identity,
      |                                          ^~~~~~~~
p1153.cpp:248:12: error: 'indirect_binary_predicate' has not been declared
  248 |            indirect_binary_predicate<projected<iterator_t<R>, Proj>,
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:248:37: error: expected '>' before '<' token
  248 |            indirect_binary_predicate<projected<iterator_t<R>, Proj>,
      |                                     ^
p1153.cpp:252:67: error: expected unqualified-id before ';' token
  252 |     count(InputIterator first, InputIterator last, const T& value);
      |                                                                   ^
p1153.cpp:255:22: error: expected ',' or '...' before '&&' token
  255 | count(ExecutionPolicy&& exec, // see 27.3.5
      |                      ^~
p1153.cpp:258:3: error: 'constexpr' does not name a type
  258 |   constexpr typename iterator_traits<InputIterator>::difference_type
      |   ^~~~~~~~~
p1153.cpp:258:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:261:84: error: expected ',' or '...' before '&&' token
  261 | typename iterator_traits<ForwardIterator>::difference_type count_if(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                    ^~
p1153.cpp:263:32: error: 'projected' does not name a type
  263 |                                projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
      |                                ^~~~~~~~~
p1153.cpp:264:36: error: expected unqualified-id before ',' token
  264 | adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
      |                                    ^
p1153.cpp:264:43: error: expected constructor, destructor, or type conversion before 'proj'
  264 | adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
      |                                           ^~~~
p1153.cpp:264:52: error: expected unqualified-id before ')' token
  264 | adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
      |                                                    ^
p1153.cpp:265:5: error: 'constexpr' does not name a type
  265 |     constexpr borrowed_iterator_t<R>
      |     ^~~~~~~~~
p1153.cpp:265:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:268:12: error: 'input_iterator' has not been declared
  268 |   template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
      |            ^~~~~~~~~~~~~~
p1153.cpp:268:30: error: 'sentinel_for' has not been declared
  268 |   template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
      |                              ^~~~~~~~~~~~
p1153.cpp:268:42: error: expected '>' before '<' token
  268 |   template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
      |                                          ^
p1153.cpp:269:5: error: 'requires' does not name a type
  269 |     requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
      |     ^~~~~~~~
p1153.cpp:269:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:271:60: error: expected unqualified-id before ')' token
  271 |       count(I first, S last, const T& value, Proj proj = {});
      |                                                            ^
p1153.cpp:272:12: error: 'input_range' has not been declared
  272 |   template<input_range R, class T, class Proj = identity>
      |            ^~~~~~~~~~~
p1153.cpp:272:49: error: 'identity' does not name a type
  272 |   template<input_range R, class T, class Proj = identity>
      |                                                 ^~~~~~~~
p1153.cpp:273:5: error: 'requires' does not name a type
  273 |     requires indirect_binary_predicate<ranges::equal_to,
      |     ^~~~~~~~
p1153.cpp:273:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:276:50: error: expected unqualified-id before ')' token
  276 |       count(R&& r, const T& value, Proj proj = {});
      |                                                  ^
p1153.cpp:277:12: error: 'input_iterator' has not been declared
  277 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~
p1153.cpp:277:30: error: 'sentinel_for' has not been declared
  277 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1153.cpp:277:42: error: expected '>' before '<' token
  277 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                          ^
p1153.cpp:280:56: error: expected unqualified-id before '{' token
  280 |       count_if(I first, S last, Pred pred, Proj proj = {});
      |                                                        ^
p1153.cpp:280:58: error: expected unqualified-id before ')' token
  280 |       count_if(I first, S last, Pred pred, Proj proj = {});
      |                                                          ^
p1153.cpp:281:12: error: 'input_range' has not been declared
  281 |   template<input_range R, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:281:40: error: 'identity' does not name a type
  281 |   template<input_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1153.cpp:282:12: error: 'indirect_unary_predicate' has not been declared
  282 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:282:36: error: expected '>' before '<' token
  282 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                    ^
p1153.cpp:284:46: error: expected unqualified-id before '{' token
  284 |       count_if(R&& r, Pred pred, Proj proj = {});
      |                                              ^
p1153.cpp:284:48: error: expected unqualified-id before ')' token
  284 |       count_if(R&& r, Pred pred, Proj proj = {});
      |                                                ^
p1153.cpp:288:3: error: 'constexpr' does not name a type
  288 |   constexpr pair<InputIterator1, InputIterator2>
      |   ^~~~~~~~~
p1153.cpp:288:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:292:3: error: 'constexpr' does not name a type
  292 |   constexpr pair<InputIterator1, InputIterator2>
      |   ^~~~~~~~~
p1153.cpp:292:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:296:3: error: 'constexpr' does not name a type
  296 |   constexpr pair<InputIterator1, InputIterator2>
      |   ^~~~~~~~~
p1153.cpp:296:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:300:3: error: 'constexpr' does not name a type
  300 |   constexpr pair<InputIterator1, InputIterator2>
      |   ^~~~~~~~~
p1153.cpp:300:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:306:25: error: expected ',' or '...' before '&&' token
  306 | mismatch(ExecutionPolicy&& exec, // see 27.3.5
      |                         ^~
p1153.cpp:312:25: error: expected ',' or '...' before '&&' token
  312 | mismatch(ExecutionPolicy&& exec, // see 27.3.5
      |                         ^~
p1153.cpp:316:25: error: expected ',' or '...' before '&&' token
  316 | mismatch(ExecutionPolicy&& exec, // see 27.3.5
      |                         ^~
p1153.cpp:321:27: error: expected ',' or '...' before '&&' token
  321 |   mismatch(ExecutionPolicy&& exec,
      |                           ^~
p1153.cpp:328:5: error: expected unqualified-id before 'using'
  328 |     using mismatch_result = in_in_result<I1, I2>;
      |     ^~~~~
p1153.cpp:329:12: error: 'input_iterator' has not been declared
  329 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |            ^~~~~~~~~~~~~~
p1153.cpp:329:31: error: 'sentinel_for' has not been declared
  329 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                               ^~~~~~~~~~~~
p1153.cpp:329:43: error: expected '>' before '<' token
  329 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                           ^
p1153.cpp:331:5: error: 'requires' does not name a type
  331 |     requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:331:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:333:72: error: expected unqualified-id before ',' token
  333 |       mismatch(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
      |                                                                        ^
p1153.cpp:334:22: error: expected constructor, destructor, or type conversion before 'proj1'
  334 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                      ^~~~~
p1153.cpp:334:32: error: expected unqualified-id before ',' token
  334 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                ^
p1153.cpp:334:40: error: expected constructor, destructor, or type conversion before 'proj2'
  334 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                        ^~~~~
p1153.cpp:334:50: error: expected unqualified-id before ')' token
  334 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                  ^
p1153.cpp:335:12: error: 'input_range' has not been declared
  335 |   template<input_range R1, input_range R2,
      |            ^~~~~~~~~~~
p1153.cpp:335:28: error: 'input_range' has not been declared
  335 |   template<input_range R1, input_range R2,
      |                            ^~~~~~~~~~~
p1153.cpp:336:33: error: 'equal_to' in namespace 'std::ranges' does not name a type
  336 |            class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
      |                                 ^~~~~~~~
p1153.cpp:336:57: error: 'identity' does not name a type
  336 |            class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
      |                                                         ^~~~~~~~
p1153.cpp:336:81: error: 'identity' does not name a type
  336 |            class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
      |                                                                                 ^~~~~~~~
p1153.cpp:337:5: error: 'requires' does not name a type
  337 |     requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:337:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:339:48: error: expected unqualified-id before ',' token
  339 |       mismatch(R1&& r1, R2&& r2, Pred pred = {},
      |                                                ^
p1153.cpp:340:22: error: expected constructor, destructor, or type conversion before 'proj1'
  340 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                      ^~~~~
p1153.cpp:340:32: error: expected unqualified-id before ',' token
  340 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                ^
p1153.cpp:340:40: error: expected constructor, destructor, or type conversion before 'proj2'
  340 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                        ^~~~~
p1153.cpp:340:50: error: expected unqualified-id before ')' token
  340 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                  ^
p1153.cpp:344:3: error: 'constexpr' does not name a type
  344 |   constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
      |   ^~~~~~~~~
p1153.cpp:344:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:347:3: error: 'constexpr' does not name a type
  347 |   constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
      |   ^~~~~~~~~
p1153.cpp:347:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:350:3: error: 'constexpr' does not name a type
  350 |   constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
      |   ^~~~~~~~~
p1153.cpp:350:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:353:3: error: 'constexpr' does not name a type
  353 |   constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
      |   ^~~~~~~~~
p1153.cpp:353:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:357:27: error: expected ',' or '...' before '&&' token
  357 | bool equal(ExecutionPolicy&& exec, // see 27.3.5
      |                           ^~
p1153.cpp:361:27: error: expected ',' or '...' before '&&' token
  361 | bool equal(ExecutionPolicy&& exec, // see 27.3.5
      |                           ^~
p1153.cpp:363:107: error: expected ',' or '...' before '&&' token
  363 | cutionPolicy, class ForwardIterator1, class ForwardIterator2> bool equal(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                         ^~

p1153.cpp:368:27: error: expected ',' or '...' before '&&' token
  368 | bool equal(ExecutionPolicy&& exec,
      |                           ^~
p1153.cpp:374:12: error: 'input_iterator' has not been declared
  374 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |            ^~~~~~~~~~~~~~
p1153.cpp:374:31: error: 'sentinel_for' has not been declared
  374 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                               ^~~~~~~~~~~~
p1153.cpp:374:43: error: expected '>' before '<' token
  374 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                           ^
p1153.cpp:376:5: error: 'requires' does not name a type
  376 |     requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:376:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:378:40: error: expected unqualified-id before ',' token
  378 |                          Pred pred = {},
      |                                        ^
p1153.cpp:379:32: error: expected constructor, destructor, or type conversion before 'proj1'
  379 |                          Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                ^~~~~
p1153.cpp:379:42: error: expected unqualified-id before ',' token
  379 |                          Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                          ^
p1153.cpp:379:50: error: expected constructor, destructor, or type conversion before 'proj2'
  379 |                          Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                  ^~~~~
p1153.cpp:379:60: error: expected unqualified-id before ')' token
  379 |                          Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                            ^
p1153.cpp:380:12: error: 'input_range' has not been declared
  380 |   template<input_range R1, input_range R2, class Pred = ranges::equal_to,
      |            ^~~~~~~~~~~
p1153.cpp:380:28: error: 'input_range' has not been declared
  380 |   template<input_range R1, input_range R2, class Pred = ranges::equal_to,
      |                            ^~~~~~~~~~~
p1153.cpp:380:65: error: 'equal_to' in namespace 'std::ranges' does not name a type
  380 |   template<input_range R1, input_range R2, class Pred = ranges::equal_to,
      |                                                                 ^~~~~~~~
p1153.cpp:381:26: error: 'identity' does not name a type
  381 |            class Proj1 = identity, class Proj2 = identity>
      |                          ^~~~~~~~
p1153.cpp:381:50: error: 'identity' does not name a type
  381 |            class Proj1 = identity, class Proj2 = identity>
      |                                                  ^~~~~~~~
p1153.cpp:382:5: error: 'requires' does not name a type
  382 |     requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:382:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:383:58: error: expected unqualified-id before ',' token
  383 |     constexpr bool equal(R1&& r1, R2&& r2, Pred pred = {},
      |                                                          ^
p1153.cpp:384:7: error: expected constructor, destructor, or type conversion before 'proj1'
  384 | Proj1 proj1 = {}, Proj2 proj2 = {});
      |       ^~~~~
p1153.cpp:384:17: error: expected unqualified-id before ',' token
  384 | Proj1 proj1 = {}, Proj2 proj2 = {});
      |                 ^
p1153.cpp:384:25: error: expected constructor, destructor, or type conversion before 'proj2'
  384 | Proj1 proj1 = {}, Proj2 proj2 = {});
      |                         ^~~~~
p1153.cpp:384:35: error: expected unqualified-id before ')' token
  384 | Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                   ^
p1153.cpp:388:3: error: 'constexpr' does not name a type
  388 |   constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
      |   ^~~~~~~~~
p1153.cpp:388:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:391:3: error: 'constexpr' does not name a type
  391 |   constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
      |   ^~~~~~~~~
p1153.cpp:391:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:394:3: error: 'constexpr' does not name a type
  394 |   constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
      |   ^~~~~~~~~
p1153.cpp:394:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:397:3: error: 'constexpr' does not name a type
  397 |   constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
      |   ^~~~~~~~~
p1153.cpp:397:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:401:12: error: 'forward_iterator' has not been declared
  401 |   template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:401:33: error: 'sentinel_for' has not been declared
  401 |   template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
      |                                 ^~~~~~~~~~~~
p1153.cpp:401:45: error: expected '>' before '<' token
  401 |   template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
      |                                             ^
p1153.cpp:406:47: error: expected unqualified-id before '{' token
  406 |                                   Pred pred = {},
      |                                               ^
p1153.cpp:406:49: error: expected unqualified-id before ',' token
  406 |                                   Pred pred = {},
      |                                                 ^
p1153.cpp:407:41: error: expected constructor, destructor, or type conversion before 'proj1'
  407 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                         ^~~~~
p1153.cpp:407:51: error: expected unqualified-id before ',' token
  407 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^
p1153.cpp:407:59: error: expected constructor, destructor, or type conversion before 'proj2'
  407 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                           ^~~~~
p1153.cpp:407:69: error: expected unqualified-id before ')' token
  407 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                     ^
p1153.cpp:408:12: error: 'forward_range' has not been declared
  408 |   template<forward_range R1, forward_range R2,
      |            ^~~~~~~~~~~~~
p1153.cpp:408:30: error: 'forward_range' has not been declared
  408 |   template<forward_range R1, forward_range R2,
      |                              ^~~~~~~~~~~~~
p1153.cpp:409:26: error: 'identity' does not name a type
  409 |            class Proj1 = identity, class Proj2 = identity,
      |                          ^~~~~~~~
p1153.cpp:409:50: error: 'identity' does not name a type
  409 |            class Proj1 = identity, class Proj2 = identity,
      |                                                  ^~~~~~~~
p1153.cpp:410:12: error: 'indirect_equivalence_relation' has not been declared
  410 |            indirect_equivalence_relation<projected<iterator_t<R1>, Proj1>,
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:410:41: error: expected '>' before '<' token
  410 |            indirect_equivalence_relation<projected<iterator_t<R1>, Proj1>,
      |                                         ^
p1153.cpp:413:65: error: expected unqualified-id before '{' token
  413 |     constexpr bool is_permutation(R1&& r1, R2&& r2, Pred pred = {},
      |                                                                 ^
p1153.cpp:413:67: error: expected unqualified-id before ',' token
  413 |     constexpr bool is_permutation(R1&& r1, R2&& r2, Pred pred = {},
      |                                                                   ^
p1153.cpp:414:41: error: expected constructor, destructor, or type conversion before 'proj1'
  414 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                         ^~~~~
p1153.cpp:414:51: error: expected unqualified-id before ',' token
  414 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^
p1153.cpp:414:59: error: expected constructor, destructor, or type conversion before 'proj2'
  414 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                           ^~~~~
p1153.cpp:414:69: error: expected unqualified-id before ')' token
  414 |                                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                     ^
p1153.cpp:418:3: error: 'constexpr' does not name a type
  418 |   constexpr ForwardIterator1
      |   ^~~~~~~~~
p1153.cpp:418:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:422:3: error: 'constexpr' does not name a type
  422 |   constexpr ForwardIterator1
      |   ^~~~~~~~~
p1153.cpp:422:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:428:23: error: expected ',' or '...' before '&&' token
  428 | search(ExecutionPolicy&& exec, // see 27.3.5
      |                       ^~
p1153.cpp:434:25: error: expected ',' or '...' before '&&' token
  434 |   search(ExecutionPolicy&& exec,
      |                         ^~
p1153.cpp:440:12: error: 'forward_iterator' has not been declared
  440 |   template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:440:33: error: 'sentinel_for' has not been declared
  440 |   template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
      |                                 ^~~~~~~~~~~~
p1153.cpp:440:45: error: expected '>' before '<' token
  440 |   template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
      |                                             ^
p1153.cpp:443:5: error: 'requires' does not name a type
  443 |     requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:443:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:445:64: error: expected unqualified-id before ',' token
  445 | search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
      |                                                                ^
p1153.cpp:446:20: error: expected constructor, destructor, or type conversion before 'proj1'
  446 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                    ^~~~~
p1153.cpp:446:30: error: expected unqualified-id before ',' token
  446 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                              ^
p1153.cpp:446:38: error: expected constructor, destructor, or type conversion before 'proj2'
  446 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                      ^~~~~
p1153.cpp:446:48: error: expected unqualified-id before ')' token
  446 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                ^
p1153.cpp:447:12: error: 'forward_range' has not been declared
  447 |   template<forward_range R1, forward_range R2, class Pred = ranges::equal_to,
      |            ^~~~~~~~~~~~~
p1153.cpp:447:30: error: 'forward_range' has not been declared
  447 |   template<forward_range R1, forward_range R2, class Pred = ranges::equal_to,
      |                              ^~~~~~~~~~~~~
p1153.cpp:447:69: error: 'equal_to' in namespace 'std::ranges' does not name a type
  447 |   template<forward_range R1, forward_range R2, class Pred = ranges::equal_to,
      |                                                                     ^~~~~~~~
p1153.cpp:448:26: error: 'identity' does not name a type
  448 |            class Proj1 = identity, class Proj2 = identity>
      |                          ^~~~~~~~
p1153.cpp:448:50: error: 'identity' does not name a type
  448 |            class Proj1 = identity, class Proj2 = identity>
      |                                                  ^~~~~~~~
p1153.cpp:449:5: error: 'requires' does not name a type
  449 |     requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:449:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:451:46: error: expected unqualified-id before ',' token
  451 |       search(R1&& r1, R2&& r2, Pred pred = {},
      |                                              ^
p1153.cpp:452:20: error: expected constructor, destructor, or type conversion before 'proj1'
  452 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                    ^~~~~
p1153.cpp:452:30: error: expected unqualified-id before ',' token
  452 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                              ^
p1153.cpp:452:38: error: expected constructor, destructor, or type conversion before 'proj2'
  452 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                      ^~~~~
p1153.cpp:452:48: error: expected unqualified-id before ')' token
  452 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                ^
p1153.cpp:455:3: error: 'constexpr' does not name a type
  455 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1153.cpp:455:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:459:3: error: 'constexpr' does not name a type
  459 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1153.cpp:459:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:464:25: error: expected ',' or '...' before '&&' token
  464 | search_n(ExecutionPolicy&& exec, // see 27.3.5
      |                         ^~
p1153.cpp:470:29: error: expected ',' or '...' before '&&' token
  470 |     search_n(ExecutionPolicy&& exec,
      |                             ^~
p1153.cpp:475:12: error: 'forward_iterator' has not been declared
  475 |   template<forward_iterator I, sentinel_for<I> S, class T,
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:475:32: error: 'sentinel_for' has not been declared
  475 |   template<forward_iterator I, sentinel_for<I> S, class T,
      |                                ^~~~~~~~~~~~
p1153.cpp:475:44: error: expected '>' before '<' token
  475 |   template<forward_iterator I, sentinel_for<I> S, class T,
      |                                            ^
p1153.cpp:478:5: error: 'requires' does not name a type
  478 |     requires indirectly_comparable<I, const T*, Pred, Proj>
      |     ^~~~~~~~
p1153.cpp:478:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:481:46: error: expected unqualified-id before ',' token
  481 |                const T& value, Pred pred = {}, Proj proj = {});
      |                                              ^
p1153.cpp:481:53: error: expected constructor, destructor, or type conversion before 'proj'
  481 |                const T& value, Pred pred = {}, Proj proj = {});
      |                                                     ^~~~
p1153.cpp:481:62: error: expected unqualified-id before ')' token
  481 |                const T& value, Pred pred = {}, Proj proj = {});
      |                                                              ^
p1153.cpp:482:12: error: 'forward_range' has not been declared
  482 |   template<forward_range R, class T, class Pred = ranges::equal_to,
      |            ^~~~~~~~~~~~~
p1153.cpp:482:59: error: 'equal_to' in namespace 'std::ranges' does not name a type
  482 |   template<forward_range R, class T, class Pred = ranges::equal_to,
      |                                                           ^~~~~~~~
p1153.cpp:483:25: error: 'identity' does not name a type
  483 |            class Proj = identity>
      |                         ^~~~~~~~
p1153.cpp:484:5: error: 'requires' does not name a type
  484 |     requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj>
      |     ^~~~~~~~
p1153.cpp:484:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:487:46: error: expected unqualified-id before ',' token
  487 |                const T& value, Pred pred = {}, Proj proj = {});
      |                                              ^
p1153.cpp:487:53: error: expected constructor, destructor, or type conversion before 'proj'
  487 |                const T& value, Pred pred = {}, Proj proj = {});
      |                                                     ^~~~
p1153.cpp:487:62: error: expected unqualified-id before ')' token
  487 |                const T& value, Pred pred = {}, Proj proj = {});
      |                                                              ^
p1153.cpp:490:3: error: 'constexpr' does not name a type
  490 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1153.cpp:490:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:494:10: error: 'input_iterator' has not been declared
  494 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |          ^~~~~~~~~~~~~~
p1153.cpp:494:29: error: 'sentinel_for' has not been declared
  494 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                             ^~~~~~~~~~~~
p1153.cpp:494:41: error: expected '>' before '<' token
  494 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                         ^
p1153.cpp:496:5: error: 'requires' does not name a type
  496 |     requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:496:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:497:88: error: expected unqualified-id before ',' token
  497 |     constexpr bool starts_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
      |                                                                                        ^
p1153.cpp:498:38: error: expected constructor, destructor, or type conversion before 'proj1'
  498 |                                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                      ^~~~~
p1153.cpp:498:48: error: expected unqualified-id before ',' token
  498 |                                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                ^
p1153.cpp:498:56: error: expected constructor, destructor, or type conversion before 'proj2'
  498 |                                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                        ^~~~~
p1153.cpp:498:66: error: expected unqualified-id before ')' token
  498 |                                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                  ^
p1153.cpp:499:12: error: 'input_range' has not been declared
  499 |   template<input_range R1, input_range R2, class Pred = ranges::equal_to,
      |            ^~~~~~~~~~~
p1153.cpp:499:28: error: 'input_range' has not been declared
  499 |   template<input_range R1, input_range R2, class Pred = ranges::equal_to,
      |                            ^~~~~~~~~~~
p1153.cpp:499:65: error: 'equal_to' in namespace 'std::ranges' does not name a type
  499 |   template<input_range R1, input_range R2, class Pred = ranges::equal_to,
      |                                                                 ^~~~~~~~
p1153.cpp:500:26: error: 'identity' does not name a type
  500 |            class Proj1 = identity, class Proj2 = identity>
      |                          ^~~~~~~~
p1153.cpp:500:50: error: 'identity' does not name a type
  500 |            class Proj1 = identity, class Proj2 = identity>
      |                                                  ^~~~~~~~
p1153.cpp:501:5: error: 'requires' does not name a type
  501 |     requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:501:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:502:64: error: expected unqualified-id before ',' token
  502 |     constexpr bool starts_with(R1&& r1, R2&& r2, Pred pred = {},
      |                                                                ^
p1153.cpp:503:38: error: expected constructor, destructor, or type conversion before 'proj1'
  503 |                                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                      ^~~~~
p1153.cpp:503:48: error: expected unqualified-id before ',' token
  503 |                                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                ^
p1153.cpp:503:56: error: expected constructor, destructor, or type conversion before 'proj2'
  503 |                                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                        ^~~~~
p1153.cpp:503:66: error: expected unqualified-id before ')' token
  503 |                                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                  ^
p1153.cpp:505:10: error: 'input_iterator' has not been declared
  505 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |          ^~~~~~~~~~~~~~
p1153.cpp:505:29: error: 'sentinel_for' has not been declared
  505 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                             ^~~~~~~~~~~~
p1153.cpp:505:41: error: expected '>' before '<' token
  505 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                         ^
p1153.cpp:507:14: error: expected constructor, destructor, or type conversion before '(' token
  507 |     requires (forward_iterator<I1> || sized_sentinel_for<S1, I1>) &&
      |              ^
p1153.cpp:510:86: error: expected unqualified-id before ',' token
  510 |     constexpr bool ends_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
      |                                                                                      ^
p1153.cpp:511:36: error: expected constructor, destructor, or type conversion before 'proj1'
  511 |                              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                    ^~~~~
p1153.cpp:511:46: error: expected unqualified-id before ',' token
  511 |                              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                              ^
p1153.cpp:511:54: error: expected constructor, destructor, or type conversion before 'proj2'
  511 |                              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                      ^~~~~
p1153.cpp:511:64: error: expected unqualified-id before ')' token
  511 |                              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                ^
p1153.cpp:512:12: error: 'input_range' has not been declared
  512 |   template<input_range R1, input_range R2, class Pred = ranges::equal_to,
      |            ^~~~~~~~~~~
p1153.cpp:512:28: error: 'input_range' has not been declared
  512 |   template<input_range R1, input_range R2, class Pred = ranges::equal_to,
      |                            ^~~~~~~~~~~
p1153.cpp:512:65: error: 'equal_to' in namespace 'std::ranges' does not name a type
  512 |   template<input_range R1, input_range R2, class Pred = ranges::equal_to,
      |                                                                 ^~~~~~~~
p1153.cpp:513:26: error: 'identity' does not name a type
  513 |            class Proj1 = identity, class Proj2 = identity>
      |                          ^~~~~~~~
p1153.cpp:513:50: error: 'identity' does not name a type
  513 |            class Proj1 = identity, class Proj2 = identity>
      |                                                  ^~~~~~~~
p1153.cpp:514:14: error: expected constructor, destructor, or type conversion before '(' token
  514 |     requires (forward_range<R1> || sized_range<R1>) &&
      |              ^
p1153.cpp:517:62: error: expected unqualified-id before ',' token
  517 |     constexpr bool ends_with(R1&& r1, R2&& r2, Pred pred = {},
      |                                                              ^
p1153.cpp:518:36: error: expected constructor, destructor, or type conversion before 'proj1'
  518 |                              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                    ^~~~~
p1153.cpp:518:46: error: expected unqualified-id before ',' token
  518 |                              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                              ^
p1153.cpp:518:54: error: expected constructor, destructor, or type conversion before 'proj2'
  518 |                              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                      ^~~~~
p1153.cpp:518:64: error: expected unqualified-id before ')' token
  518 |                              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                ^
p1153.cpp:523:3: error: 'constexpr' does not name a type
  523 |   constexpr OutputIterator copy(InputIterator first, InputIterator last,
      |   ^~~~~~~~~
p1153.cpp:523:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:525:118: error: expected ',' or '...' before '&&' token
  525 | y, class ForwardIterator1, class ForwardIterator2> ForwardIterator2 copy(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                         ^~

p1153.cpp:530:5: error: expected unqualified-id before 'using'
  530 |     using copy_result = in_out_result<I, O>;
      |     ^~~~~
p1153.cpp:531:12: error: 'input_iterator' has not been declared
  531 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
      |            ^~~~~~~~~~~~~~
p1153.cpp:531:30: error: 'sentinel_for' has not been declared
  531 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
      |                              ^~~~~~~~~~~~
p1153.cpp:531:42: error: expected '>' before '<' token
  531 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
      |                                          ^
p1153.cpp:532:5: error: 'requires' does not name a type
  532 |     requires indirectly_copyable<I, O>
      |     ^~~~~~~~
p1153.cpp:532:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:535:12: error: 'input_range' has not been declared
  535 |   template<input_range R, weakly_incrementable O>
      |            ^~~~~~~~~~~
p1153.cpp:535:27: error: 'weakly_incrementable' has not been declared
  535 |   template<input_range R, weakly_incrementable O>
      |                           ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:536:5: error: 'requires' does not name a type
  536 |     requires indirectly_copyable<iterator_t<R>, O>
      |     ^~~~~~~~
p1153.cpp:536:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:541:3: error: 'constexpr' does not name a type
  541 |   constexpr OutputIterator copy_n(InputIterator first, Size n,
      |   ^~~~~~~~~
p1153.cpp:541:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:545:42: error: expected ',' or '...' before '&&' token
  545 |   ForwardIterator2 copy_n(ExecutionPolicy&& exec,
      |                                          ^~
p1153.cpp:550:5: error: expected unqualified-id before 'using'
  550 |     using copy_n_result = in_out_result<I, O>;
      |     ^~~~~
p1153.cpp:551:12: error: 'input_iterator' has not been declared
  551 |   template<input_iterator I, weakly_incrementable O>
      |            ^~~~~~~~~~~~~~
p1153.cpp:551:30: error: 'weakly_incrementable' has not been declared
  551 |   template<input_iterator I, weakly_incrementable O>
      |                              ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:552:5: error: 'requires' does not name a type
  552 |     requires indirectly_copyable<I, O>
      |     ^~~~~~~~
p1153.cpp:552:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:557:3: error: 'constexpr' does not name a type
  557 |   constexpr OutputIterator copy_if(InputIterator first, InputIterator last,
      |   ^~~~~~~~~
p1153.cpp:557:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:562:41: error: expected ',' or '...' before '&&' token
  562 | ForwardIterator2 copy_if(ExecutionPolicy&& exec, // see 27.3.5
      |                                         ^~
p1153.cpp:567:5: error: expected unqualified-id before 'using'
  567 |     using copy_if_result = in_out_result<I, O>;
      |     ^~~~~
p1153.cpp:568:12: error: 'input_iterator' has not been declared
  568 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
      |            ^~~~~~~~~~~~~~
p1153.cpp:568:30: error: 'sentinel_for' has not been declared
  568 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1153.cpp:568:42: error: expected '>' before '<' token
  568 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
      |                                          ^
p1153.cpp:572:65: error: expected unqualified-id before '{' token
  572 |       copy_if(I first, S last, O result, Pred pred, Proj proj = {});
      |                                                                 ^
p1153.cpp:572:67: error: expected unqualified-id before ')' token
  572 |       copy_if(I first, S last, O result, Pred pred, Proj proj = {});
      |                                                                   ^
p1153.cpp:573:12: error: 'input_range' has not been declared
  573 |   template<input_range R, weakly_incrementable O, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:573:27: error: 'weakly_incrementable' has not been declared
  573 |   template<input_range R, weakly_incrementable O, class Proj = identity,
      |                           ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:573:64: error: 'identity' does not name a type
  573 |   template<input_range R, weakly_incrementable O, class Proj = identity,
      |                                                                ^~~~~~~~
p1153.cpp:574:12: error: 'indirect_unary_predicate' has not been declared
  574 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:574:36: error: expected '>' before '<' token
  574 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                    ^
p1153.cpp:577:55: error: expected unqualified-id before '{' token
  577 |       copy_if(R&& r, O result, Pred pred, Proj proj = {});
      |                                                       ^
p1153.cpp:577:57: error: expected unqualified-id before ')' token
  577 |       copy_if(R&& r, O result, Pred pred, Proj proj = {});
      |                                                         ^
p1153.cpp:580:3: error: 'constexpr' does not name a type
  580 |   constexpr BidirectionalIterator2
      |   ^~~~~~~~~
p1153.cpp:580:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:585:5: error: expected unqualified-id before 'using'
  585 |     using copy_backward_result = in_out_result<I1, I2>;
      |     ^~~~~
p1153.cpp:586:12: error: 'bidirectional_iterator' has not been declared
  586 |   template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:586:39: error: 'sentinel_for' has not been declared
  586 |   template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
      |                                       ^~~~~~~~~~~~
p1153.cpp:586:51: error: expected '>' before '<' token
  586 |   template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
      |                                                   ^
p1153.cpp:587:5: error: 'requires' does not name a type
  587 |     requires indirectly_copyable<I1, I2>
      |     ^~~~~~~~
p1153.cpp:587:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:590:12: error: 'bidirectional_range' has not been declared
  590 |   template<bidirectional_range R, bidirectional_iterator I>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:590:35: error: 'bidirectional_iterator' has not been declared
  590 |   template<bidirectional_range R, bidirectional_iterator I>
      |                                   ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:591:5: error: 'requires' does not name a type
  591 |     requires indirectly_copyable<iterator_t<R>, I>
      |     ^~~~~~~~
p1153.cpp:591:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:597:3: error: 'constexpr' does not name a type
  597 |   constexpr OutputIterator move(InputIterator first, InputIterator last,
      |   ^~~~~~~~~
p1153.cpp:597:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:601:38: error: expected ',' or '...' before '&&' token
  601 | ForwardIterator2 move(ExecutionPolicy&& exec, // see 27.3.5
      |                                      ^~
p1153.cpp:606:5: error: expected unqualified-id before 'using'
  606 |     using move_result = in_out_result<I, O>;
      |     ^~~~~
p1153.cpp:607:12: error: 'input_iterator' has not been declared
  607 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
      |            ^~~~~~~~~~~~~~
p1153.cpp:607:30: error: 'sentinel_for' has not been declared
  607 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
      |                              ^~~~~~~~~~~~
p1153.cpp:607:42: error: expected '>' before '<' token
  607 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
      |                                          ^
p1153.cpp:608:5: error: 'requires' does not name a type
  608 |     requires indirectly_movable<I, O>
      |     ^~~~~~~~
p1153.cpp:608:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:611:12: error: 'input_range' has not been declared
  611 |   template<input_range R, weakly_incrementable O>
      |            ^~~~~~~~~~~
p1153.cpp:611:27: error: 'weakly_incrementable' has not been declared
  611 |   template<input_range R, weakly_incrementable O>
      |                           ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:612:5: error: 'requires' does not name a type
  612 |     requires indirectly_movable<iterator_t<R>, O>
      |     ^~~~~~~~
p1153.cpp:612:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:617:3: error: 'constexpr' does not name a type
  617 |   constexpr BidirectionalIterator2
      |   ^~~~~~~~~
p1153.cpp:617:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:622:5: error: expected unqualified-id before 'using'
  622 |     using move_backward_result = in_out_result<I1, I2>;
      |     ^~~~~
p1153.cpp:623:12: error: 'bidirectional_iterator' has not been declared
  623 |   template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:623:39: error: 'sentinel_for' has not been declared
  623 |   template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
      |                                       ^~~~~~~~~~~~
p1153.cpp:623:51: error: expected '>' before '<' token
  623 |   template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
      |                                                   ^
p1153.cpp:624:5: error: 'requires' does not name a type
  624 |     requires indirectly_movable<I1, I2>
      |     ^~~~~~~~
p1153.cpp:624:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:627:12: error: 'bidirectional_range' has not been declared
  627 |   template<bidirectional_range R, bidirectional_iterator I>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:627:35: error: 'bidirectional_iterator' has not been declared
  627 |   template<bidirectional_range R, bidirectional_iterator I>
      |                                   ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:628:5: error: 'requires' does not name a type
  628 |     requires indirectly_movable<iterator_t<R>, I>
      |     ^~~~~~~~
p1153.cpp:628:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:634:3: error: 'constexpr' does not name a type
  634 |   constexpr ForwardIterator2 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1,
      |   ^~~~~~~~~
p1153.cpp:634:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:636:125: error: expected ',' or '...' before '&&' token
  636 | s ForwardIterator1, class ForwardIterator2> ForwardIterator2 swap_ranges(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                         ^~

p1153.cpp:641:5: error: expected unqualified-id before 'using'
  641 |     using swap_ranges_result = in_in_result<I1, I2>;
      |     ^~~~~
p1153.cpp:642:12: error: 'input_iterator' has not been declared
  642 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2>
      |            ^~~~~~~~~~~~~~
p1153.cpp:642:31: error: 'sentinel_for' has not been declared
  642 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2>
      |                               ^~~~~~~~~~~~
p1153.cpp:642:43: error: expected '>' before '<' token
  642 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2>
      |                                           ^
p1153.cpp:643:5: error: 'requires' does not name a type
  643 |     requires indirectly_swappable<I1, I2>
      |     ^~~~~~~~
p1153.cpp:643:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:646:12: error: 'input_range' has not been declared
  646 |   template<input_range R1, input_range R2>
      |            ^~~~~~~~~~~
p1153.cpp:646:28: error: 'input_range' has not been declared
  646 |   template<input_range R1, input_range R2>
      |                            ^~~~~~~~~~~
p1153.cpp:647:5: error: 'requires' does not name a type
  647 |     requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
      |     ^~~~~~~~
p1153.cpp:647:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:652:3: error: 'constexpr' does not name a type
  652 |   constexpr void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
      |   ^~~~~~~~~
p1153.cpp:652:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:655:3: error: 'constexpr' does not name a type
  655 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:655:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:660:3: error: 'constexpr' does not name a type
  660 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:660:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:667:26: error: expected ',' or '...' before '&&' token
  667 | transform(ExecutionPolicy&& exec, // see 27.3.5
      |                          ^~
p1153.cpp:673:26: error: expected ',' or '...' before '&&' token
  673 | transform(ExecutionPolicy&& exec, // see 27.3.5
      |                          ^~
p1153.cpp:679:5: error: expected unqualified-id before 'using'
  679 |     using unary_transform_result = in_out_result<I, O>;
      |     ^~~~~
p1153.cpp:680:12: error: 'input_iterator' has not been declared
  680 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
      |            ^~~~~~~~~~~~~~
p1153.cpp:680:30: error: 'sentinel_for' has not been declared
  680 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
      |                              ^~~~~~~~~~~~
p1153.cpp:680:42: error: expected '>' before '<' token
  680 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
      |                                          ^
p1153.cpp:682:5: error: 'requires' does not name a type
  682 |     requires indirectly_writable<O, indirect_result_t<F&, projected<I, Proj>>>
      |     ^~~~~~~~
p1153.cpp:682:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:684:66: error: expected unqualified-id before ')' token
  684 |       transform(I first1, S last1, O result, F op, Proj proj = {});
      |                                                                  ^
p1153.cpp:685:12: error: 'input_range' has not been declared
  685 |   template<input_range R, weakly_incrementable O, copy_constructible F,
      |            ^~~~~~~~~~~
p1153.cpp:685:27: error: 'weakly_incrementable' has not been declared
  685 |   template<input_range R, weakly_incrementable O, copy_constructible F,
      |                           ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:685:51: error: 'copy_constructible' has not been declared
  685 |   template<input_range R, weakly_incrementable O, copy_constructible F,
      |                                                   ^~~~~~~~~~~~~~~~~~
p1153.cpp:686:25: error: 'identity' does not name a type
  686 |            class Proj = identity>
      |                         ^~~~~~~~
p1153.cpp:687:5: error: 'requires' does not name a type
  687 |     requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
      |     ^~~~~~~~
p1153.cpp:687:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:689:54: error: expected unqualified-id before ')' token
  689 |       transform(R&& r, O result, F op, Proj proj = {});
      |                                                      ^
p1153.cpp:691:5: error: expected unqualified-id before 'using'
  691 |     using binary_transform_result = in_in_out_result<I1, I2, O>;
      |     ^~~~~
p1153.cpp:692:12: error: 'input_iterator' has not been declared
  692 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |            ^~~~~~~~~~~~~~
p1153.cpp:692:31: error: 'sentinel_for' has not been declared
  692 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                               ^~~~~~~~~~~~
p1153.cpp:692:43: error: expected '>' before '<' token
  692 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                           ^
p1153.cpp:695:5: error: 'requires' does not name a type
  695 |     requires indirectly_writable<O, indirect_result_t<F&, projected<I1, Proj1>,
      |     ^~~~~~~~
p1153.cpp:695:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:699:46: error: expected unqualified-id before ',' token
  699 |                 F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                              ^
p1153.cpp:699:54: error: expected constructor, destructor, or type conversion before 'proj2'
  699 |                 F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                      ^~~~~
p1153.cpp:699:64: error: expected unqualified-id before ')' token
  699 |                 F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                ^
p1153.cpp:700:12: error: 'input_range' has not been declared
  700 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |            ^~~~~~~~~~~
p1153.cpp:700:28: error: 'input_range' has not been declared
  700 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |                            ^~~~~~~~~~~
p1153.cpp:700:44: error: 'weakly_incrementable' has not been declared
  700 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |                                            ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:701:12: error: 'copy_constructible' has not been declared
  701 |            copy_constructible F, class Proj1 = identity, class Proj2 = identity>
      |            ^~~~~~~~~~~~~~~~~~
p1153.cpp:701:48: error: 'identity' does not name a type
  701 |            copy_constructible F, class Proj1 = identity, class Proj2 = identity>
      |                                                ^~~~~~~~
p1153.cpp:701:72: error: 'identity' does not name a type
  701 |            copy_constructible F, class Proj1 = identity, class Proj2 = identity>
      |                                                                        ^~~~~~~~
p1153.cpp:702:5: error: 'requires' does not name a type
  702 |     requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
      |     ^~~~~~~~
p1153.cpp:702:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:706:46: error: expected unqualified-id before ',' token
  706 |                 F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                              ^
p1153.cpp:706:54: error: expected constructor, destructor, or type conversion before 'proj2'
  706 |                 F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                      ^~~~~
p1153.cpp:706:64: error: expected unqualified-id before ')' token
  706 |                 F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                ^
p1153.cpp:710:3: error: 'constexpr' does not name a type
  710 |   constexpr void replace(ForwardIterator first, ForwardIterator last,
      |   ^~~~~~~~~
p1153.cpp:710:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:713:29: error: expected ',' or '...' before '&&' token
  713 | void replace(ExecutionPolicy&& exec, // see 27.3.5
      |                             ^~
p1153.cpp:717:3: error: 'constexpr' does not name a type
  717 |   constexpr void replace_if(ForwardIterator first, ForwardIterator last,
      |   ^~~~~~~~~
p1153.cpp:717:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:719:113: error: expected ',' or '...' before '&&' token
  719 | Policy, class ForwardIterator, class Predicate, class T> void replace_if(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                         ^~

p1153.cpp:723:12: error: 'input_iterator' has not been declared
  723 |   template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity>
      |            ^~~~~~~~~~~~~~
p1153.cpp:723:30: error: 'sentinel_for' has not been declared
  723 |   template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity>
      |                              ^~~~~~~~~~~~
p1153.cpp:723:42: error: expected '>' before '<' token
  723 |   template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity>
      |                                          ^
p1153.cpp:724:5: error: 'requires' does not name a type
  724 |     requires indirectly_writable<I, const T2&> &&
      |     ^~~~~~~~
p1153.cpp:724:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:727:88: error: expected unqualified-id before ')' token
  727 |       replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});
      |                                                                                        ^
p1153.cpp:728:12: error: 'input_range' has not been declared
  728 |   template<input_range R, class T1, class T2, class Proj = identity>
      |            ^~~~~~~~~~~
p1153.cpp:728:60: error: 'identity' does not name a type
  728 |   template<input_range R, class T1, class T2, class Proj = identity>
      |                                                            ^~~~~~~~
p1153.cpp:729:5: error: 'requires' does not name a type
  729 |     requires indirectly_writable<iterator_t<R>, const T2&> &&
      |     ^~~~~~~~
p1153.cpp:729:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:733:78: error: expected unqualified-id before ')' token
  733 |       replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});
      |                                                                              ^
p1153.cpp:734:12: error: 'input_iterator' has not been declared
  734 |   template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |            ^~~~~~~~~~~~~~
p1153.cpp:734:30: error: 'sentinel_for' has not been declared
  734 |   template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1153.cpp:734:42: error: expected '>' before '<' token
  734 |   template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                                          ^
p1153.cpp:737:88: error: expected unqualified-id before '{' token
  737 |     constexpr I replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
      |                                                                                        ^
p1153.cpp:737:90: error: expected unqualified-id before ')' token
  737 |     constexpr I replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
      |                                                                                          ^
p1153.cpp:738:12: error: 'input_range' has not been declared
  738 |   template<input_range R, class T, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:738:49: error: 'identity' does not name a type
  738 |   template<input_range R, class T, class Proj = identity,
      |                                                 ^~~~~~~~
p1153.cpp:739:12: error: 'indirect_unary_predicate' has not been declared
  739 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:739:36: error: expected '>' before '<' token
  739 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                    ^
p1153.cpp:742:68: error: expected unqualified-id before '{' token
  742 |       replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
      |                                                                    ^
p1153.cpp:742:70: error: expected unqualified-id before ')' token
  742 |       replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
      |                                                                      ^
p1153.cpp:745:3: error: 'constexpr' does not name a type
  745 |   constexpr OutputIterator replace_copy(InputIterator first, InputIterator last,
      |   ^~~~~~~~~
p1153.cpp:745:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:749:46: error: expected ',' or '...' before '&&' token
  749 | ForwardIterator2 replace_copy(ExecutionPolicy&& exec, // see 27.3.5
      |                                              ^~
p1153.cpp:754:3: error: 'constexpr' does not name a type
  754 |   constexpr OutputIterator replace_copy_if(InputIterator first, InputIterator last,
      |   ^~~~~~~~~
p1153.cpp:754:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:759:49: error: expected ',' or '...' before '&&' token
  759 | ForwardIterator2 replace_copy_if(ExecutionPolicy&& exec, // see 27.3.5
      |                                                 ^~
p1153.cpp:798:83: error: expected ')' before ';' token
  798 |   constexpr void fill(ForwardIterator first, ForwardIterator last, const T& value);
      |                                                                                   ^
      |                                                                                   )
p1153.cpp:759:33: note: to match this '('
  759 | ForwardIterator2 replace_copy_if(ExecutionPolicy&& exec, // see 27.3.5
      |                                 ^
p1153.cpp:800:26: error: expected ',' or '...' before '&&' token
  800 | void fill(ExecutionPolicy&& exec, // see 27.3.5
      |                          ^~
p1153.cpp:803:3: error: 'constexpr' does not name a type
  803 |   constexpr OutputIterator fill_n(OutputIterator first, Size n, const T& value);
      |   ^~~~~~~~~
p1153.cpp:803:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:806:39: error: expected ',' or '...' before '&&' token
  806 | ForwardIterator fill_n(ExecutionPolicy&& exec, // see 27.3.5
      |                                       ^~
p1153.cpp:809:21: error: 'output_iterator' has not been declared
  809 |   template<class T, output_iterator<const T&> O, sentinel_for<O> S>
      |                     ^~~~~~~~~~~~~~~
p1153.cpp:809:36: error: expected '>' before '<' token
  809 |   template<class T, output_iterator<const T&> O, sentinel_for<O> S>
      |                                    ^
p1153.cpp:810:5: error: 'constexpr' does not name a type
  810 |     constexpr O fill(O first, S last, const T& value);
      |     ^~~~~~~~~
p1153.cpp:810:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:811:21: error: 'output_range' has not been declared
  811 |   template<class T, output_range<const T&> R>
      |                     ^~~~~~~~~~~~
p1153.cpp:811:33: error: expected '>' before '<' token
  811 |   template<class T, output_range<const T&> R>
      |                                 ^
p1153.cpp:812:5: error: 'constexpr' does not name a type
  812 |     constexpr borrowed_iterator_t<R> fill(R&& r, const T& value);
      |     ^~~~~~~~~
p1153.cpp:812:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:813:21: error: 'output_iterator' has not been declared
  813 |   template<class T, output_iterator<const T&> O>
      |                     ^~~~~~~~~~~~~~~
p1153.cpp:813:36: error: expected '>' before '<' token
  813 |   template<class T, output_iterator<const T&> O>
      |                                    ^
p1153.cpp:814:5: error: 'constexpr' does not name a type
  814 |     constexpr O fill_n(O first, iter_difference_t<O> n, const T& value);
      |     ^~~~~~~~~
p1153.cpp:814:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:818:3: error: 'constexpr' does not name a type
  818 |   constexpr void generate(ForwardIterator first, ForwardIterator last,
      |   ^~~~~~~~~
p1153.cpp:818:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:820:102: error: expected ',' or '...' before '&&' token
  820 | s ExecutionPolicy, class ForwardIterator, class Generator> void generate(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                         ^~

p1153.cpp:824:3: error: 'constexpr' does not name a type
  824 |   constexpr OutputIterator generate_n(OutputIterator first, Size n, Generator gen);
      |   ^~~~~~~~~
p1153.cpp:824:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:826:43: error: expected ',' or '...' before '&&' token
  826 | ForwardIterator generate_n(ExecutionPolicy&& exec, // see 27.3.5
      |                                           ^~
p1153.cpp:829:12: error: 'input_or_output_iterator' has not been declared
  829 |   template<input_or_output_iterator O, sentinel_for<O> S, copy_constructible F>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:829:40: error: 'sentinel_for' has not been declared
  829 |   template<input_or_output_iterator O, sentinel_for<O> S, copy_constructible F>
      |                                        ^~~~~~~~~~~~
p1153.cpp:829:52: error: expected '>' before '<' token
  829 |   template<input_or_output_iterator O, sentinel_for<O> S, copy_constructible F>
      |                                                    ^
p1153.cpp:830:5: error: 'requires' does not name a type
  830 |     requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
      |     ^~~~~~~~
p1153.cpp:830:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:832:21: error: 'copy_constructible' has not been declared
  832 |   template<class R, copy_constructible F>
      |                     ^~~~~~~~~~~~~~~~~~
p1153.cpp:833:5: error: 'requires' does not name a type
  833 |     requires invocable<F&> && output_range<R, invoke_result_t<F&>>
      |     ^~~~~~~~
p1153.cpp:833:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:835:12: error: 'input_or_output_iterator' has not been declared
  835 |   template<input_or_output_iterator O, copy_constructible F>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:835:40: error: 'copy_constructible' has not been declared
  835 |   template<input_or_output_iterator O, copy_constructible F>
      |                                        ^~~~~~~~~~~~~~~~~~
p1153.cpp:836:5: error: 'requires' does not name a type
  836 |     requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
      |     ^~~~~~~~
p1153.cpp:836:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:841:3: error: 'constexpr' does not name a type
  841 |   constexpr ForwardIterator remove(ForwardIterator first, ForwardIterator last,
      |   ^~~~~~~~~
p1153.cpp:841:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:843:103: error: expected ',' or '...' before '&&' token
  843 |  ExecutionPolicy, class ForwardIterator, class T> ForwardIterator remove(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                         ^~

p1153.cpp:847:3: error: 'constexpr' does not name a type
  847 |   constexpr ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
      |   ^~~~~~~~~
p1153.cpp:847:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:849:114: error: expected ',' or '...' before '&&' token
  849 | olicy, class ForwardIterator, class Predicate> ForwardIterator remove_if(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                         ^~

p1153.cpp:853:12: error: 'permutable' has not been declared
  853 |   template<permutable I, sentinel_for<I> S, class T, class Proj = identity>
      |            ^~~~~~~~~~
p1153.cpp:853:26: error: 'sentinel_for' has not been declared
  853 |   template<permutable I, sentinel_for<I> S, class T, class Proj = identity>
      |                          ^~~~~~~~~~~~
p1153.cpp:853:38: error: expected '>' before '<' token
  853 |   template<permutable I, sentinel_for<I> S, class T, class Proj = identity>
      |                                      ^
p1153.cpp:854:5: error: 'requires' does not name a type
  854 |     requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
      |     ^~~~~~~~
p1153.cpp:854:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:855:81: error: expected unqualified-id before ')' token
  855 |     constexpr subrange<I> remove(I first, S last, const T& value, Proj proj = {});
      |                                                                                 ^
p1153.cpp:856:12: error: 'forward_range' has not been declared
  856 |   template<forward_range R, class T, class Proj = identity>
      |            ^~~~~~~~~~~~~
p1153.cpp:856:51: error: 'identity' does not name a type
  856 |   template<forward_range R, class T, class Proj = identity>
      |                                                   ^~~~~~~~
p1153.cpp:857:5: error: 'requires' does not name a type
  857 |     requires permutable<iterator_t<R>> &&
      |     ^~~~~~~~
p1153.cpp:857:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:861:51: error: expected unqualified-id before ')' token
  861 |       remove(R&& r, const T& value, Proj proj = {});
      |                                                   ^
p1153.cpp:862:12: error: 'permutable' has not been declared
  862 |   template<permutable I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~
p1153.cpp:862:26: error: 'sentinel_for' has not been declared
  862 |   template<permutable I, sentinel_for<I> S, class Proj = identity,
      |                          ^~~~~~~~~~~~
p1153.cpp:862:38: error: expected '>' before '<' token
  862 |   template<permutable I, sentinel_for<I> S, class Proj = identity,
      |                                      ^
p1153.cpp:864:77: error: expected unqualified-id before '{' token
  864 |     constexpr subrange<I> remove_if(I first, S last, Pred pred, Proj proj = {});
      |                                                                             ^
p1153.cpp:864:79: error: expected unqualified-id before ')' token
  864 |     constexpr subrange<I> remove_if(I first, S last, Pred pred, Proj proj = {});
      |                                                                               ^
p1153.cpp:865:12: error: 'forward_range' has not been declared
  865 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:865:42: error: 'identity' does not name a type
  865 |   template<forward_range R, class Proj = identity,
      |                                          ^~~~~~~~
p1153.cpp:866:12: error: 'indirect_unary_predicate' has not been declared
  866 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:866:36: error: expected '>' before '<' token
  866 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                    ^
p1153.cpp:869:47: error: expected unqualified-id before '{' token
  869 |       remove_if(R&& r, Pred pred, Proj proj = {});
      |                                               ^
p1153.cpp:869:49: error: expected unqualified-id before ')' token
  869 |       remove_if(R&& r, Pred pred, Proj proj = {});
      |                                                 ^
p1153.cpp:872:3: error: 'constexpr' does not name a type
  872 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:872:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:878:28: error: expected ',' or '...' before '&&' token
  878 | remove_copy(ExecutionPolicy&& exec, // see 27.3.5
      |                            ^~
p1153.cpp:882:3: error: 'constexpr' does not name a type
  882 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:882:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:888:31: error: expected ',' or '...' before '&&' token
  888 | remove_copy_if(ExecutionPolicy&& exec, // see 27.3.5
      |                               ^~
p1153.cpp:893:5: error: expected unqualified-id before 'using'
  893 |     using remove_copy_result = in_out_result<I, O>;
      |     ^~~~~
p1153.cpp:894:12: error: 'input_iterator' has not been declared
  894 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class T,
      |            ^~~~~~~~~~~~~~
p1153.cpp:894:30: error: 'sentinel_for' has not been declared
  894 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class T,
      |                              ^~~~~~~~~~~~
p1153.cpp:894:42: error: expected '>' before '<' token
  894 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class T,
      |                                          ^
p1153.cpp:896:5: error: 'requires' does not name a type
  896 |     requires indirectly_copyable<I, O> &&
      |     ^~~~~~~~
p1153.cpp:896:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:899:76: error: expected unqualified-id before ')' token
  899 |       remove_copy(I first, S last, O result, const T& value, Proj proj = {});
      |                                                                            ^
p1153.cpp:900:12: error: 'input_range' has not been declared
  900 |   template<input_range R, weakly_incrementable O, class T, class Proj = identity>
      |            ^~~~~~~~~~~
p1153.cpp:900:27: error: 'weakly_incrementable' has not been declared
  900 |   template<input_range R, weakly_incrementable O, class T, class Proj = identity>
      |                           ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:900:73: error: 'identity' does not name a type
  900 |   template<input_range R, weakly_incrementable O, class T, class Proj = identity>
      |                                                                         ^~~~~~~~
p1153.cpp:901:5: error: 'requires' does not name a type
  901 |     requires indirectly_copyable<iterator_t<R>, O> &&
      |     ^~~~~~~~
p1153.cpp:901:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:905:66: error: expected unqualified-id before ')' token
  905 |       remove_copy(R&& r, O result, const T& value, Proj proj = {});
      |                                                                  ^
p1153.cpp:907:5: error: expected unqualified-id before 'using'
  907 |     using remove_copy_if_result = in_out_result<I, O>;
      |     ^~~~~
p1153.cpp:908:12: error: 'input_iterator' has not been declared
  908 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
      |            ^~~~~~~~~~~~~~
p1153.cpp:908:30: error: 'sentinel_for' has not been declared
  908 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
      |                              ^~~~~~~~~~~~
p1153.cpp:908:42: error: expected '>' before '<' token
  908 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
      |                                          ^
p1153.cpp:912:72: error: expected unqualified-id before '{' token
  912 |       remove_copy_if(I first, S last, O result, Pred pred, Proj proj = {});
      |                                                                        ^
p1153.cpp:912:74: error: expected unqualified-id before ')' token
  912 |       remove_copy_if(I first, S last, O result, Pred pred, Proj proj = {});
      |                                                                          ^
p1153.cpp:913:12: error: 'input_range' has not been declared
  913 |   template<input_range R, weakly_incrementable O, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:913:27: error: 'weakly_incrementable' has not been declared
  913 |   template<input_range R, weakly_incrementable O, class Proj = identity,
      |                           ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:913:64: error: 'identity' does not name a type
  913 |   template<input_range R, weakly_incrementable O, class Proj = identity,
      |                                                                ^~~~~~~~
p1153.cpp:914:12: error: 'indirect_unary_predicate' has not been declared
  914 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:914:36: error: expected '>' before '<' token
  914 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                    ^
p1153.cpp:917:62: error: expected unqualified-id before '{' token
  917 |       remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});
      |                                                              ^
p1153.cpp:917:64: error: expected unqualified-id before ')' token
  917 |       remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});
      |                                                                ^
p1153.cpp:921:3: error: 'constexpr' does not name a type
  921 |   constexpr ForwardIterator unique(ForwardIterator first, ForwardIterator last);
      |   ^~~~~~~~~
p1153.cpp:921:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:923:3: error: 'constexpr' does not name a type
  923 |   constexpr ForwardIterator unique(ForwardIterator first, ForwardIterator last,
      |   ^~~~~~~~~
p1153.cpp:923:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:926:39: error: expected ',' or '...' before '&&' token
  926 | ForwardIterator unique(ExecutionPolicy&& exec, // see 27.3.5
      |                                       ^~
p1153.cpp:929:39: error: expected ',' or '...' before '&&' token
  929 | ForwardIterator unique(ExecutionPolicy&& exec, // see 27.3.5
      |                                       ^~
p1153.cpp:933:12: error: 'permutable' has not been declared
  933 |   template<permutable I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~
p1153.cpp:933:26: error: 'sentinel_for' has not been declared
  933 |   template<permutable I, sentinel_for<I> S, class Proj = identity,
      |                          ^~~~~~~~~~~~
p1153.cpp:933:38: error: expected '>' before '<' token
  933 |   template<permutable I, sentinel_for<I> S, class Proj = identity,
      |                                      ^
p1153.cpp:935:60: error: expected unqualified-id before '{' token
  935 |     constexpr subrange<I> unique(I first, S last, C comp = {}, Proj proj = {});
      |                                                            ^
p1153.cpp:935:62: error: expected unqualified-id before ',' token
  935 |     constexpr subrange<I> unique(I first, S last, C comp = {}, Proj proj = {});
      |                                                              ^
p1153.cpp:935:69: error: expected constructor, destructor, or type conversion before 'proj'
  935 |     constexpr subrange<I> unique(I first, S last, C comp = {}, Proj proj = {});
      |                                                                     ^~~~
p1153.cpp:935:78: error: expected unqualified-id before ')' token
  935 |     constexpr subrange<I> unique(I first, S last, C comp = {}, Proj proj = {});
      |                                                                              ^
p1153.cpp:936:12: error: 'forward_range' has not been declared
  936 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:936:42: error: 'identity' does not name a type
  936 |   template<forward_range R, class Proj = identity,
      |                                          ^~~~~~~~
p1153.cpp:937:12: error: 'indirect_equivalence_relation' has not been declared
  937 |            indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:937:41: error: expected '>' before '<' token
  937 |            indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
      |                                         ^
p1153.cpp:940:30: error: expected unqualified-id before '{' token
  940 |       unique(R&& r, C comp = {}, Proj proj = {});
      |                              ^
p1153.cpp:940:32: error: expected unqualified-id before ',' token
  940 |       unique(R&& r, C comp = {}, Proj proj = {});
      |                                ^
p1153.cpp:940:39: error: expected constructor, destructor, or type conversion before 'proj'
  940 |       unique(R&& r, C comp = {}, Proj proj = {});
      |                                       ^~~~
p1153.cpp:940:48: error: expected unqualified-id before ')' token
  940 |       unique(R&& r, C comp = {}, Proj proj = {});
      |                                                ^
p1153.cpp:943:3: error: 'constexpr' does not name a type
  943 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:943:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:947:3: error: 'constexpr' does not name a type
  947 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:947:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:952:28: error: expected ',' or '...' before '&&' token
  952 | unique_copy(ExecutionPolicy&& exec, // see 27.3.5
      |                            ^~
p1153.cpp:958:28: error: expected ',' or '...' before '&&' token
  958 | unique_copy(ExecutionPolicy&& exec, // see 27.3.5
      |                            ^~
p1153.cpp:963:5: error: expected unqualified-id before 'using'
  963 |     using unique_copy_result = in_out_result<I, O>;
      |     ^~~~~
p1153.cpp:964:12: error: 'input_iterator' has not been declared
  964 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
      |            ^~~~~~~~~~~~~~
p1153.cpp:964:30: error: 'sentinel_for' has not been declared
  964 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1153.cpp:964:42: error: expected '>' before '<' token
  964 |   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
      |                                          ^
p1153.cpp:971:55: error: expected unqualified-id before '{' token
  971 |       unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});
      |                                                       ^
p1153.cpp:971:57: error: expected unqualified-id before ',' token
  971 |       unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});
      |                                                         ^
p1153.cpp:971:64: error: expected constructor, destructor, or type conversion before 'proj'
  971 |       unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});
      |                                                                ^~~~
p1153.cpp:971:73: error: expected unqualified-id before ')' token
  971 |       unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});
      |                                                                         ^
p1153.cpp:972:12: error: 'input_range' has not been declared
  972 |   template<input_range R, weakly_incrementable O, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:972:27: error: 'weakly_incrementable' has not been declared
  972 |   template<input_range R, weakly_incrementable O, class Proj = identity,
      |                           ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:972:64: error: 'identity' does not name a type
  972 |   template<input_range R, weakly_incrementable O, class Proj = identity,
      |                                                                ^~~~~~~~
p1153.cpp:973:12: error: 'indirect_equivalence_relation' has not been declared
  973 |            indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:973:41: error: expected '>' before '<' token
  973 |            indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
      |                                         ^
p1153.cpp:979:45: error: expected unqualified-id before '{' token
  979 |       unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
      |                                             ^
p1153.cpp:979:47: error: expected unqualified-id before ',' token
  979 |       unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
      |                                               ^
p1153.cpp:979:54: error: expected constructor, destructor, or type conversion before 'proj'
  979 |       unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
      |                                                      ^~~~
p1153.cpp:979:63: error: expected unqualified-id before ')' token
  979 |       unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
      |                                                               ^
p1153.cpp:983:3: error: 'constexpr' does not name a type
  983 |   constexpr void reverse(BidirectionalIterator first, BidirectionalIterator last);
      |   ^~~~~~~~~
p1153.cpp:983:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:985:29: error: expected ',' or '...' before '&&' token
  985 | void reverse(ExecutionPolicy&& exec, // see 27.3.5
      |                             ^~
p1153.cpp:988:12: error: 'bidirectional_iterator' has not been declared
  988 |   template<bidirectional_iterator I, sentinel_for<I> S>
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:988:38: error: 'sentinel_for' has not been declared
  988 |   template<bidirectional_iterator I, sentinel_for<I> S>
      |                                      ^~~~~~~~~~~~
p1153.cpp:988:50: error: expected '>' before '<' token
  988 |   template<bidirectional_iterator I, sentinel_for<I> S>
      |                                                  ^
p1153.cpp:989:5: error: 'requires' does not name a type
  989 |     requires permutable<I>
      |     ^~~~~~~~
p1153.cpp:989:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:991:12: error: 'bidirectional_range' has not been declared
  991 |   template<bidirectional_range R>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:992:5: error: 'requires' does not name a type
  992 |     requires permutable<iterator_t<R>>
      |     ^~~~~~~~
p1153.cpp:992:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:996:3: error: 'constexpr' does not name a type
  996 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:996:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1001:29: error: expected ',' or '...' before '&&' token
 1001 | reverse_copy(ExecutionPolicy&& exec, // see 27.3.5
      |                             ^~
p1153.cpp:1005:5: error: expected unqualified-id before 'using'
 1005 |     using reverse_copy_result = in_out_result<I, O>;
      |     ^~~~~
p1153.cpp:1006:10: error: 'bidirectional_iterator' has not been declared
 1006 | template<bidirectional_iterator I, sentinel_for<I> S, weakly_incrementable O>
      |          ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1006:36: error: 'sentinel_for' has not been declared
 1006 | template<bidirectional_iterator I, sentinel_for<I> S, weakly_incrementable O>
      |                                    ^~~~~~~~~~~~
p1153.cpp:1006:48: error: expected '>' before '<' token
 1006 | template<bidirectional_iterator I, sentinel_for<I> S, weakly_incrementable O>
      |                                                ^
p1153.cpp:1007:3: error: 'requires' does not name a type
 1007 |   requires indirectly_copyable<I, O>
      |   ^~~~~~~~
p1153.cpp:1007:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1010:12: error: 'bidirectional_range' has not been declared
 1010 |   template<bidirectional_range R, weakly_incrementable O>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1010:35: error: 'weakly_incrementable' has not been declared
 1010 |   template<bidirectional_range R, weakly_incrementable O>
      |                                   ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:1011:5: error: 'requires' does not name a type
 1011 |     requires indirectly_copyable<iterator_t<R>, O>
      |     ^~~~~~~~
p1153.cpp:1011:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1017:3: error: 'constexpr' does not name a type
 1017 |   constexpr ForwardIterator rotate(ForwardIterator first,
      |   ^~~~~~~~~
p1153.cpp:1017:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1021:41: error: expected ',' or '...' before '&&' token
 1021 |   ForwardIterator rotate(ExecutionPolicy&& exec,
      |                                         ^~
p1153.cpp:1026:12: error: 'permutable' has not been declared
 1026 |   template<permutable I, sentinel_for<I> S>
      |            ^~~~~~~~~~
p1153.cpp:1026:26: error: 'sentinel_for' has not been declared
 1026 |   template<permutable I, sentinel_for<I> S>
      |                          ^~~~~~~~~~~~
p1153.cpp:1026:38: error: expected '>' before '<' token
 1026 |   template<permutable I, sentinel_for<I> S>
      |                                      ^
p1153.cpp:1027:5: error: 'constexpr' does not name a type
 1027 |     constexpr subrange<I> rotate(I first, I middle, S last);
      |     ^~~~~~~~~
p1153.cpp:1027:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1028:12: error: 'forward_range' has not been declared
 1028 |   template<forward_range R>
      |            ^~~~~~~~~~~~~
p1153.cpp:1029:5: error: 'requires' does not name a type
 1029 |     requires permutable<iterator_t<R>>
      |     ^~~~~~~~
p1153.cpp:1029:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1034:3: error: 'constexpr' does not name a type
 1034 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:1034:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1039:28: error: expected ',' or '...' before '&&' token
 1039 | rotate_copy(ExecutionPolicy&& exec, // see 27.3.5
      |                            ^~
p1153.cpp:1043:5: error: expected unqualified-id before 'using'
 1043 |     using rotate_copy_result = in_out_result<I, O>;
      |     ^~~~~
p1153.cpp:1044:12: error: 'forward_iterator' has not been declared
 1044 |   template<forward_iterator I, sentinel_for<I> S, weakly_incrementable O>
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:1044:32: error: 'sentinel_for' has not been declared
 1044 |   template<forward_iterator I, sentinel_for<I> S, weakly_incrementable O>
      |                                ^~~~~~~~~~~~
p1153.cpp:1044:44: error: expected '>' before '<' token
 1044 |   template<forward_iterator I, sentinel_for<I> S, weakly_incrementable O>
      |                                            ^
p1153.cpp:1045:5: error: 'requires' does not name a type
 1045 |     requires indirectly_copyable<I, O>
      |     ^~~~~~~~
p1153.cpp:1045:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1048:12: error: 'forward_range' has not been declared
 1048 |   template<forward_range R, weakly_incrementable O>
      |            ^~~~~~~~~~~~~
p1153.cpp:1048:29: error: 'weakly_incrementable' has not been declared
 1048 |   template<forward_range R, weakly_incrementable O>
      |                             ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:1049:5: error: 'requires' does not name a type
 1049 |     requires indirectly_copyable<iterator_t<R>, O>
      |     ^~~~~~~~
p1153.cpp:1049:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1058:50: error: expected ',' or '...' before '&&' token
 1058 |                         UniformRandomBitGenerator&& g);
      |                                                  ^~
p1153.cpp:1060:12: error: 'input_iterator' has not been declared
 1060 |   template<input_iterator I, sentinel_for<I> S,
      |            ^~~~~~~~~~~~~~
p1153.cpp:1060:30: error: 'sentinel_for' has not been declared
 1060 |   template<input_iterator I, sentinel_for<I> S,
      |                              ^~~~~~~~~~~~
p1153.cpp:1060:42: error: expected '>' before '<' token
 1060 |   template<input_iterator I, sentinel_for<I> S,
      |                                          ^
p1153.cpp:1062:14: error: expected constructor, destructor, or type conversion before '(' token
 1062 |     requires (forward_iterator<I> || random_access_iterator<O>) &&
      |              ^
p1153.cpp:1066:12: error: 'input_range' has not been declared
 1066 |   template<input_range R, weakly_incrementable O, class Gen>
      |            ^~~~~~~~~~~
p1153.cpp:1066:27: error: 'weakly_incrementable' has not been declared
 1066 |   template<input_range R, weakly_incrementable O, class Gen>
      |                           ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:1067:14: error: expected constructor, destructor, or type conversion before '(' token
 1067 |     requires (forward_range<R> || random_access_iterator<O>) &&
      |              ^
p1153.cpp:1076:41: error: expected ',' or '...' before '&&' token
 1076 |                UniformRandomBitGenerator&& g);
      |                                         ^~
p1153.cpp:1078:12: error: 'random_access_iterator' has not been declared
 1078 |   template<random_access_iterator I, sentinel_for<I> S, class Gen>
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1078:38: error: 'sentinel_for' has not been declared
 1078 |   template<random_access_iterator I, sentinel_for<I> S, class Gen>
      |                                      ^~~~~~~~~~~~
p1153.cpp:1078:50: error: expected '>' before '<' token
 1078 |   template<random_access_iterator I, sentinel_for<I> S, class Gen>
      |                                                  ^
p1153.cpp:1079:5: error: 'requires' does not name a type
 1079 |     requires permutable<I> &&
      |     ^~~~~~~~
p1153.cpp:1079:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1082:12: error: 'random_access_range' has not been declared
 1082 |   template<random_access_range R, class Gen>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1083:5: error: 'requires' does not name a type
 1083 |     requires permutable<iterator_t<R>> &&
      |     ^~~~~~~~
p1153.cpp:1083:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1089:3: error: 'constexpr' does not name a type
 1089 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1153.cpp:1089:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1094:27: error: expected ',' or '...' before '&&' token
 1094 | shift_left(ExecutionPolicy&& exec, // see 27.3.5
      |                           ^~
p1153.cpp:1098:12: error: 'permutable' has not been declared
 1098 |   template<permutable I, sentinel_for<I> S>
      |            ^~~~~~~~~~
p1153.cpp:1098:26: error: 'sentinel_for' has not been declared
 1098 |   template<permutable I, sentinel_for<I> S>
      |                          ^~~~~~~~~~~~
p1153.cpp:1098:38: error: expected '>' before '<' token
 1098 |   template<permutable I, sentinel_for<I> S>
      |                                      ^
p1153.cpp:1099:5: error: 'constexpr' does not name a type
 1099 |     constexpr subrange<I> shift_left(I first, S last, iter_difference_t<I> n);
      |     ^~~~~~~~~
p1153.cpp:1099:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1100:12: error: 'forward_range' has not been declared
 1100 |   template<forward_range R>
      |            ^~~~~~~~~~~~~
p1153.cpp:1101:5: error: 'requires' does not name a type
 1101 |     requires permutable<iterator_t<R>>
      |     ^~~~~~~~
p1153.cpp:1101:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1105:3: error: 'constexpr' does not name a type
 1105 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1153.cpp:1105:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1110:28: error: expected ',' or '...' before '&&' token
 1110 | shift_right(ExecutionPolicy&& exec, // see 27.3.5
      |                            ^~
p1153.cpp:1114:12: error: 'permutable' has not been declared
 1114 |   template<permutable I, sentinel_for<I> S>
      |            ^~~~~~~~~~
p1153.cpp:1114:26: error: 'sentinel_for' has not been declared
 1114 |   template<permutable I, sentinel_for<I> S>
      |                          ^~~~~~~~~~~~
p1153.cpp:1114:38: error: expected '>' before '<' token
 1114 |   template<permutable I, sentinel_for<I> S>
      |                                      ^
p1153.cpp:1115:5: error: 'constexpr' does not name a type
 1115 |     constexpr subrange<I> shift_right(I first, S last, iter_difference_t<I> n);
      |     ^~~~~~~~~
p1153.cpp:1115:5: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1116:12: error: 'forward_range' has not been declared
 1116 |   template<forward_range R>
      |            ^~~~~~~~~~~~~
p1153.cpp:1117:5: error: 'requires' does not name a type
 1117 |     requires permutable<iterator_t<R>>
      |     ^~~~~~~~
p1153.cpp:1117:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1123:3: error: 'constexpr' does not name a type
 1123 |   constexpr void sort(RandomAccessIterator first, RandomAccessIterator last);
      |   ^~~~~~~~~
p1153.cpp:1123:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1125:3: error: 'constexpr' does not name a type
 1125 |   constexpr void sort(RandomAccessIterator first, RandomAccessIterator last,
      |   ^~~~~~~~~
p1153.cpp:1125:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1128:26: error: expected ',' or '...' before '&&' token
 1128 | void sort(ExecutionPolicy&& exec, // see 27.3.5
      |                          ^~
p1153.cpp:1131:26: error: expected ',' or '...' before '&&' token
 1131 | void sort(ExecutionPolicy&& exec, // see 27.3.5
      |                          ^~
p1153.cpp:1134:12: error: 'random_access_iterator' has not been declared
 1134 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1134:38: error: 'sentinel_for' has not been declared
 1134 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                      ^~~~~~~~~~~~
p1153.cpp:1134:50: error: expected '>' before '<' token
 1134 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                  ^
p1153.cpp:1136:5: error: 'requires' does not name a type
 1136 |     requires sortable<I, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1136:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1138:43: error: expected unqualified-id before ',' token
 1138 |       sort(I first, S last, Comp comp = {}, Proj proj = {});
      |                                           ^
p1153.cpp:1138:50: error: expected constructor, destructor, or type conversion before 'proj'
 1138 |       sort(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                  ^~~~
p1153.cpp:1138:59: error: expected unqualified-id before ')' token
 1138 |       sort(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                           ^
p1153.cpp:1139:12: error: 'random_access_range' has not been declared
 1139 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1139:56: error: 'less' in namespace 'std::ranges' does not name a type
 1139 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                        ^~~~
p1153.cpp:1139:75: error: 'identity' does not name a type
 1139 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                                           ^~~~~~~~
p1153.cpp:1140:5: error: 'requires' does not name a type
 1140 |     requires sortable<iterator_t<R>, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1140:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1142:33: error: expected unqualified-id before ',' token
 1142 |       sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                 ^
p1153.cpp:1142:40: error: expected constructor, destructor, or type conversion before 'proj'
 1142 |       sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                        ^~~~
p1153.cpp:1142:49: error: expected unqualified-id before ')' token
 1142 |       sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                                 ^
p1153.cpp:1150:33: error: expected ',' or '...' before '&&' token
 1150 | void stable_sort(ExecutionPolicy&& exec, // see 27.3.5
      |                                 ^~
p1153.cpp:1152:33: error: expected ',' or '...' before '&&' token
 1152 | void stable_sort(ExecutionPolicy&& exec, // see 27.3.5
      |                                 ^~
p1153.cpp:1156:12: error: 'random_access_iterator' has not been declared
 1156 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1156:38: error: 'sentinel_for' has not been declared
 1156 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                      ^~~~~~~~~~~~
p1153.cpp:1156:50: error: expected '>' before '<' token
 1156 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                  ^
p1153.cpp:1158:5: error: 'requires' does not name a type
 1158 |     requires sortable<I, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1158:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1159:50: error: expected unqualified-id before ',' token
 1159 |     I stable_sort(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                  ^
p1153.cpp:1159:57: error: expected constructor, destructor, or type conversion before 'proj'
 1159 |     I stable_sort(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                         ^~~~
p1153.cpp:1159:66: error: expected unqualified-id before ')' token
 1159 |     I stable_sort(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                  ^
p1153.cpp:1160:12: error: 'random_access_range' has not been declared
 1160 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1160:56: error: 'less' in namespace 'std::ranges' does not name a type
 1160 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                        ^~~~
p1153.cpp:1160:75: error: 'identity' does not name a type
 1160 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                                           ^~~~~~~~
p1153.cpp:1161:5: error: 'requires' does not name a type
 1161 |     requires sortable<iterator_t<R>, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1161:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1163:40: error: expected unqualified-id before ',' token
 1163 |       stable_sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                        ^
p1153.cpp:1163:47: error: expected constructor, destructor, or type conversion before 'proj'
 1163 |       stable_sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                               ^~~~
p1153.cpp:1163:56: error: expected unqualified-id before ')' token
 1163 |       stable_sort(R&& r, Comp comp = {}, Proj proj = {});
      |                                                        ^
p1153.cpp:1166:3: error: 'constexpr' does not name a type
 1166 |   constexpr void partial_sort(RandomAccessIterator first, RandomAccessIterator middle,
      |   ^~~~~~~~~
p1153.cpp:1166:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1169:3: error: 'constexpr' does not name a type
 1169 |   constexpr void partial_sort(RandomAccessIterator first, RandomAccessIterator middle,
      |   ^~~~~~~~~
p1153.cpp:1169:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1172:34: error: expected ',' or '...' before '&&' token
 1172 | void partial_sort(ExecutionPolicy&& exec, // see 27.3.5
      |                                  ^~
p1153.cpp:1176:34: error: expected ',' or '...' before '&&' token
 1176 | void partial_sort(ExecutionPolicy&& exec, // see 27.3.5
      |                                  ^~
p1153.cpp:1177:73: error: expected ')' before '}' token
 1177 |                 RandomAccessIterator first, RandomAccessIterator middle,
      |                                                                         ^
      |                                                                         )
 1178 | }
      | ~                                                                        
p1153.cpp:1176:18: note: to match this '('
 1176 | void partial_sort(ExecutionPolicy&& exec, // see 27.3.5
      |                  ^
p1153.cpp:1178:1: error: expected initializer before '}' token
 1178 | }
      | ^
p1153.cpp:1179:1: error: 'RandomAccessIterator' does not name a type
 1179 | RandomAccessIterator last, Compare comp);
      | ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:1181:12: error: 'random_access_iterator' has not been declared
 1181 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1181:38: error: 'sentinel_for' has not been declared
 1181 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                      ^~~~~~~~~~~~
p1153.cpp:1181:50: error: expected '>' before '<' token
 1181 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                  ^
p1153.cpp:1183:5: error: 'requires' does not name a type
 1183 |     requires sortable<I, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1183:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1185:61: error: expected unqualified-id before ',' token
 1185 |       partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});
      |                                                             ^
p1153.cpp:1185:68: error: expected constructor, destructor, or type conversion before 'proj'
 1185 |       partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});
      |                                                                    ^~~~
p1153.cpp:1185:77: error: expected unqualified-id before ')' token
 1185 |       partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});
      |                                                                             ^
p1153.cpp:1186:12: error: 'random_access_range' has not been declared
 1186 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1186:48: error: reference to 'ranges' is ambiguous
 1186 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                ^~~~~~
p1153.cpp:17:15: note: candidates are: 'namespace std::ranges { }'
   17 |     namespace ranges {
      |               ^~~~~~
p1153.cpp:1180:11: note:                 'namespace ranges { }'
 1180 | namespace ranges {
      |           ^~~~~~
p1153.cpp:1186:54: error: expected '>' before '::' token
 1186 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                      ^~
p1153.cpp:1187:5: error: 'requires' does not name a type
 1187 |     requires sortable<iterator_t<R>, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1187:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1189:63: error: expected unqualified-id before ',' token
 1189 |       partial_sort(R&& r, iterator_t<R> middle, Comp comp = {},
      |                                                               ^
p1153.cpp:1190:25: error: expected constructor, destructor, or type conversion before 'proj'
 1190 |                    Proj proj = {});
      |                         ^~~~
p1153.cpp:1190:34: error: expected unqualified-id before ')' token
 1190 |                    Proj proj = {});
      |                                  ^
p1153.cpp:1193:3: error: 'constexpr' does not name a type
 1193 |   constexpr RandomAccessIterator
      |   ^~~~~~~~~
p1153.cpp:1193:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1198:3: error: 'constexpr' does not name a type
 1198 |   constexpr RandomAccessIterator
      |   ^~~~~~~~~
p1153.cpp:1198:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1205:34: error: expected ',' or '...' before '&&' token
 1205 | partial_sort_copy(ExecutionPolicy&& exec, // see 27.3.5
      |                                  ^~
p1153.cpp:1212:34: error: expected ',' or '...' before '&&' token
 1212 | partial_sort_copy(ExecutionPolicy&& exec, // see 27.3.5
      |                                  ^~
p1153.cpp:1219:5: error: expected unqualified-id before 'using'
 1219 |     using partial_sort_copy_result = in_out_result<I, O>;
      |     ^~~~~
p1153.cpp:1220:12: error: 'input_iterator' has not been declared
 1220 |   template<input_iterator I1, sentinel_for<I1> S1,
      |            ^~~~~~~~~~~~~~
p1153.cpp:1220:31: error: 'sentinel_for' has not been declared
 1220 |   template<input_iterator I1, sentinel_for<I1> S1,
      |                               ^~~~~~~~~~~~
p1153.cpp:1220:43: error: expected '>' before '<' token
 1220 |   template<input_iterator I1, sentinel_for<I1> S1,
      |                                           ^
p1153.cpp:1223:5: error: 'requires' does not name a type
 1223 |     requires indirectly_copyable<I1, I2> && sortable<I2, Comp, Proj2> &&
      |     ^~~~~~~~
p1153.cpp:1223:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1227:39: error: expected unqualified-id before ',' token
 1227 |                         Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                       ^
p1153.cpp:1227:47: error: expected constructor, destructor, or type conversion before 'proj1'
 1227 |                         Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                               ^~~~~
p1153.cpp:1227:57: error: expected unqualified-id before ',' token
 1227 |                         Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                         ^
p1153.cpp:1227:65: error: expected constructor, destructor, or type conversion before 'proj2'
 1227 |                         Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                 ^~~~~
p1153.cpp:1227:75: error: expected unqualified-id before ')' token
 1227 |                         Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                           ^
p1153.cpp:1228:12: error: 'input_range' has not been declared
 1228 |   template<input_range R1, random_access_range R2, class Comp = ranges::less,
      |            ^~~~~~~~~~~
p1153.cpp:1228:28: error: 'random_access_range' has not been declared
 1228 |   template<input_range R1, random_access_range R2, class Comp = ranges::less,
      |                            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1228:65: error: reference to 'ranges' is ambiguous
 1228 |   template<input_range R1, random_access_range R2, class Comp = ranges::less,
      |                                                                 ^~~~~~
p1153.cpp:17:15: note: candidates are: 'namespace std::ranges { }'
   17 |     namespace ranges {
      |               ^~~~~~
p1153.cpp:1180:11: note:                 'namespace ranges { }'
 1180 | namespace ranges {
      |           ^~~~~~
p1153.cpp:1228:71: error: expected '>' before '::' token
 1228 |   template<input_range R1, random_access_range R2, class Comp = ranges::less,
      |                                                                       ^~
p1153.cpp:1230:5: error: 'requires' does not name a type
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |     ^~~~~~~~
p1153.cpp:1230:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1235:56: error: expected unqualified-id before ',' token
 1235 | partial_sort_copy(R1&& r, R2&& result_r, Comp comp = {},
      |                                                        ^
p1153.cpp:1236:25: error: expected constructor, destructor, or type conversion before 'proj1'
 1236 |                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                         ^~~~~
p1153.cpp:1236:35: error: expected unqualified-id before ',' token
 1236 |                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                   ^
p1153.cpp:1236:43: error: expected constructor, destructor, or type conversion before 'proj2'
 1236 |                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                           ^~~~~
p1153.cpp:1236:53: error: expected unqualified-id before ')' token
 1236 |                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                     ^
p1153.cpp:1238:3: error: 'constexpr' does not name a type
 1238 |   constexpr bool is_sorted(ForwardIterator first, ForwardIterator last);
      |   ^~~~~~~~~
p1153.cpp:1238:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1240:3: error: 'constexpr' does not name a type
 1240 |   constexpr bool is_sorted(ForwardIterator first, ForwardIterator last,
      |   ^~~~~~~~~
p1153.cpp:1240:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1243:31: error: expected ',' or '...' before '&&' token
 1243 | bool is_sorted(ExecutionPolicy&& exec, // see 27.3.5
      |                               ^~
p1153.cpp:1245:101: error: expected ',' or '...' before '&&' token
 1245 | ss ExecutionPolicy, class ForwardIterator, class Compare> bool is_sorted(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                         ^~

p1153.cpp:1249:12: error: 'forward_iterator' has not been declared
 1249 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:1249:32: error: 'sentinel_for' has not been declared
 1249 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                ^~~~~~~~~~~~
p1153.cpp:1249:44: error: expected '>' before '<' token
 1249 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                            ^
p1153.cpp:1251:59: error: expected unqualified-id before '{' token
 1251 |     constexpr bool is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                           ^
p1153.cpp:1251:61: error: expected unqualified-id before ',' token
 1251 |     constexpr bool is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                             ^
p1153.cpp:1251:68: error: expected constructor, destructor, or type conversion before 'proj'
 1251 |     constexpr bool is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                    ^~~~
p1153.cpp:1251:77: error: expected unqualified-id before ')' token
 1251 |     constexpr bool is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                             ^
p1153.cpp:1252:12: error: 'forward_range' has not been declared
 1252 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1252:42: error: 'identity' does not name a type
 1252 |   template<forward_range R, class Proj = identity,
      |                                          ^~~~~~~~
p1153.cpp:1253:12: error: 'indirect_strict_weak_order' has not been declared
 1253 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1253:38: error: expected '>' before '<' token
 1253 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1254:49: error: expected unqualified-id before '{' token
 1254 |     constexpr bool is_sorted(R&& r, Comp comp = {}, Proj proj = {});
      |                                                 ^
p1153.cpp:1254:51: error: expected unqualified-id before ',' token
 1254 |     constexpr bool is_sorted(R&& r, Comp comp = {}, Proj proj = {});
      |                                                   ^
p1153.cpp:1254:58: error: expected constructor, destructor, or type conversion before 'proj'
 1254 |     constexpr bool is_sorted(R&& r, Comp comp = {}, Proj proj = {});
      |                                                          ^~~~
p1153.cpp:1254:67: error: expected unqualified-id before ')' token
 1254 |     constexpr bool is_sorted(R&& r, Comp comp = {}, Proj proj = {});
      |                                                                   ^
p1153.cpp:1257:3: error: 'constexpr' does not name a type
 1257 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1153.cpp:1257:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1260:3: error: 'constexpr' does not name a type
 1260 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1153.cpp:1260:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1265:32: error: expected ',' or '...' before '&&' token
 1265 | is_sorted_until(ExecutionPolicy&& exec, // see 27.3.5
      |                                ^~
p1153.cpp:1269:32: error: expected ',' or '...' before '&&' token
 1269 | is_sorted_until(ExecutionPolicy&& exec, // see 27.3.5
      |                                ^~
p1153.cpp:1273:12: error: 'forward_iterator' has not been declared
 1273 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:1273:32: error: 'sentinel_for' has not been declared
 1273 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                ^~~~~~~~~~~~
p1153.cpp:1273:44: error: expected '>' before '<' token
 1273 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                            ^
p1153.cpp:1275:62: error: expected unqualified-id before '{' token
 1275 |     constexpr I is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                              ^
p1153.cpp:1275:64: error: expected unqualified-id before ',' token
 1275 |     constexpr I is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                ^
p1153.cpp:1275:71: error: expected constructor, destructor, or type conversion before 'proj'
 1275 |     constexpr I is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                       ^~~~
p1153.cpp:1275:80: error: expected unqualified-id before ')' token
 1275 |     constexpr I is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                                ^
p1153.cpp:1276:12: error: 'forward_range' has not been declared
 1276 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1276:42: error: 'identity' does not name a type
 1276 |   template<forward_range R, class Proj = identity,
      |                                          ^~~~~~~~
p1153.cpp:1277:12: error: 'indirect_strict_weak_order' has not been declared
 1277 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1277:38: error: expected '>' before '<' token
 1277 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1279:42: error: expected unqualified-id before '{' token
 1279 |       is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                          ^
p1153.cpp:1279:44: error: expected unqualified-id before ',' token
 1279 |       is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                            ^
p1153.cpp:1279:51: error: expected constructor, destructor, or type conversion before 'proj'
 1279 |       is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                   ^~~~
p1153.cpp:1279:60: error: expected unqualified-id before ')' token
 1279 |       is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1153.cpp:1283:3: error: 'constexpr' does not name a type
 1283 |   constexpr void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
      |   ^~~~~~~~~
p1153.cpp:1283:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1286:3: error: 'constexpr' does not name a type
 1286 |   constexpr void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
      |   ^~~~~~~~~
p1153.cpp:1286:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1289:33: error: expected ',' or '...' before '&&' token
 1289 | void nth_element(ExecutionPolicy&& exec, // see 27.3.5
      |                                 ^~
p1153.cpp:1293:33: error: expected ',' or '...' before '&&' token
 1293 | void nth_element(ExecutionPolicy&& exec, // see 27.3.5
      |                                 ^~
p1153.cpp:1297:12: error: 'random_access_iterator' has not been declared
 1297 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1297:38: error: 'sentinel_for' has not been declared
 1297 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                      ^~~~~~~~~~~~
p1153.cpp:1297:50: error: expected '>' before '<' token
 1297 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                  ^
p1153.cpp:1299:5: error: 'requires' does not name a type
 1299 |     requires sortable<I, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1299:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1301:57: error: expected unqualified-id before ',' token
 1301 |       nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
      |                                                         ^
p1153.cpp:1301:64: error: expected constructor, destructor, or type conversion before 'proj'
 1301 |       nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
      |                                                                ^~~~
p1153.cpp:1301:73: error: expected unqualified-id before ')' token
 1301 |       nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
      |                                                                         ^
p1153.cpp:1302:12: error: 'random_access_range' has not been declared
 1302 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1302:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 1302 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                        ^~~~
p1153.cpp:1302:75: error: 'identity' does not name a type
 1302 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                                           ^~~~~~~~
p1153.cpp:1303:5: error: 'requires' does not name a type
 1303 |     requires sortable<iterator_t<R>, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1303:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1305:59: error: expected unqualified-id before ',' token
 1305 |       nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
      |                                                           ^
p1153.cpp:1305:66: error: expected constructor, destructor, or type conversion before 'proj'
 1305 |       nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
      |                                                                  ^~~~
p1153.cpp:1305:75: error: expected unqualified-id before ')' token
 1305 |       nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
      |                                                                           ^
p1153.cpp:1309:3: error: 'constexpr' does not name a type
 1309 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1153.cpp:1309:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1313:3: error: 'constexpr' does not name a type
 1313 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1153.cpp:1313:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1317:12: error: 'forward_iterator' has not been declared
 1317 |   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:1317:32: error: 'sentinel_for' has not been declared
 1317 |   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                                ^~~~~~~~~~~~
p1153.cpp:1317:44: error: expected '>' before '<' token
 1317 |   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                                            ^
p1153.cpp:1319:74: error: expected unqualified-id before '{' token
 1319 |     constexpr I lower_bound(I first, S last, const T& value, Comp comp = {},
      |                                                                          ^
p1153.cpp:1319:76: error: expected unqualified-id before ',' token
 1319 |     constexpr I lower_bound(I first, S last, const T& value, Comp comp = {},
      |                                                                            ^
p1153.cpp:1320:34: error: expected constructor, destructor, or type conversion before 'proj'
 1320 |                             Proj proj = {});
      |                                  ^~~~
p1153.cpp:1320:43: error: expected unqualified-id before ')' token
 1320 |                             Proj proj = {});
      |                                           ^
p1153.cpp:1321:12: error: 'forward_range' has not been declared
 1321 |   template<forward_range R, class T, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1321:51: error: 'identity' does not name a type
 1321 |   template<forward_range R, class T, class Proj = identity,
      |                                                   ^~~~~~~~
p1153.cpp:1322:12: error: 'indirect_strict_weak_order' has not been declared
 1322 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1322:38: error: expected '>' before '<' token
 1322 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                      ^
p1153.cpp:1325:54: error: expected unqualified-id before '{' token
 1325 |       lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                      ^
p1153.cpp:1325:56: error: expected unqualified-id before ',' token
 1325 |       lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                        ^
p1153.cpp:1325:63: error: expected constructor, destructor, or type conversion before 'proj'
 1325 |       lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                               ^~~~
p1153.cpp:1325:72: error: expected unqualified-id before ')' token
 1325 |       lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                        ^
p1153.cpp:1328:3: error: 'constexpr' does not name a type
 1328 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1153.cpp:1328:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1332:3: error: 'constexpr' does not name a type
 1332 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1153.cpp:1332:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1336:12: error: 'forward_iterator' has not been declared
 1336 |   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:1336:32: error: 'sentinel_for' has not been declared
 1336 |   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                                ^~~~~~~~~~~~
p1153.cpp:1336:44: error: expected '>' before '<' token
 1336 |   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                                            ^
p1153.cpp:1338:74: error: expected unqualified-id before '{' token
 1338 |     constexpr I upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                          ^
p1153.cpp:1338:76: error: expected unqualified-id before ',' token
 1338 |     constexpr I upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                            ^
p1153.cpp:1338:83: error: expected constructor, destructor, or type conversion before 'proj'
 1338 |     constexpr I upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                                   ^~~~
p1153.cpp:1338:92: error: expected unqualified-id before ')' token
 1338 |     constexpr I upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                                            ^
p1153.cpp:1339:12: error: 'forward_range' has not been declared
 1339 |   template<forward_range R, class T, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1339:51: error: 'identity' does not name a type
 1339 |   template<forward_range R, class T, class Proj = identity,
      |                                                   ^~~~~~~~
p1153.cpp:1340:12: error: 'indirect_strict_weak_order' has not been declared
 1340 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1340:38: error: expected '>' before '<' token
 1340 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                      ^
p1153.cpp:1343:54: error: expected unqualified-id before '{' token
 1343 |       upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                      ^
p1153.cpp:1343:56: error: expected unqualified-id before ',' token
 1343 |       upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                        ^
p1153.cpp:1343:63: error: expected constructor, destructor, or type conversion before 'proj'
 1343 |       upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                               ^~~~
p1153.cpp:1343:72: error: expected unqualified-id before ')' token
 1343 |       upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                        ^
p1153.cpp:1346:3: error: 'constexpr' does not name a type
 1346 |   constexpr pair<ForwardIterator, ForwardIterator>
      |   ^~~~~~~~~
p1153.cpp:1346:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1350:3: error: 'constexpr' does not name a type
 1350 |   constexpr pair<ForwardIterator, ForwardIterator>
      |   ^~~~~~~~~
p1153.cpp:1350:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1354:12: error: 'forward_iterator' has not been declared
 1354 |   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:1354:32: error: 'sentinel_for' has not been declared
 1354 |   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                                ^~~~~~~~~~~~
p1153.cpp:1354:44: error: expected '>' before '<' token
 1354 |   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                                            ^
p1153.cpp:1357:64: error: expected unqualified-id before '{' token
 1357 |       equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                ^
p1153.cpp:1357:66: error: expected unqualified-id before ',' token
 1357 |       equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                  ^
p1153.cpp:1357:73: error: expected constructor, destructor, or type conversion before 'proj'
 1357 |       equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                         ^~~~
p1153.cpp:1357:82: error: expected unqualified-id before ')' token
 1357 |       equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                                  ^
p1153.cpp:1358:12: error: 'forward_range' has not been declared
 1358 |   template<forward_range R, class T, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1358:51: error: 'identity' does not name a type
 1358 |   template<forward_range R, class T, class Proj = identity,
      |                                                   ^~~~~~~~
p1153.cpp:1359:12: error: 'indirect_strict_weak_order' has not been declared
 1359 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1359:38: error: expected '>' before '<' token
 1359 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                      ^
p1153.cpp:1362:54: error: expected unqualified-id before '{' token
 1362 |       equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                      ^
p1153.cpp:1362:56: error: expected unqualified-id before ',' token
 1362 |       equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                        ^
p1153.cpp:1362:63: error: expected constructor, destructor, or type conversion before 'proj'
 1362 |       equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                               ^~~~
p1153.cpp:1362:72: error: expected unqualified-id before ')' token
 1362 |       equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                        ^
p1153.cpp:1365:3: error: 'constexpr' does not name a type
 1365 |   constexpr bool
      |   ^~~~~~~~~
p1153.cpp:1365:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1369:3: error: 'constexpr' does not name a type
 1369 |   constexpr bool
      |   ^~~~~~~~~
p1153.cpp:1369:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1373:12: error: 'forward_iterator' has not been declared
 1373 |   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:1373:32: error: 'sentinel_for' has not been declared
 1373 |   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                                ^~~~~~~~~~~~
p1153.cpp:1373:44: error: expected '>' before '<' token
 1373 |   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
      |                                            ^
p1153.cpp:1375:79: error: expected unqualified-id before '{' token
 1375 |     constexpr bool binary_search(I first, S last, const T& value, Comp comp = {},
      |                                                                               ^
p1153.cpp:1375:81: error: expected unqualified-id before ',' token
 1375 |     constexpr bool binary_search(I first, S last, const T& value, Comp comp = {},
      |                                                                                 ^
p1153.cpp:1376:39: error: expected constructor, destructor, or type conversion before 'proj'
 1376 |                                  Proj proj = {});
      |                                       ^~~~
p1153.cpp:1376:48: error: expected unqualified-id before ')' token
 1376 |                                  Proj proj = {});
      |                                                ^
p1153.cpp:1377:12: error: 'forward_range' has not been declared
 1377 |   template<forward_range R, class T, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1377:51: error: 'identity' does not name a type
 1377 |   template<forward_range R, class T, class Proj = identity,
      |                                                   ^~~~~~~~
p1153.cpp:1378:12: error: 'indirect_strict_weak_order' has not been declared
 1378 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1378:38: error: expected '>' before '<' token
 1378 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                      ^
p1153.cpp:1380:69: error: expected unqualified-id before '{' token
 1380 |     constexpr bool binary_search(R&& r, const T& value, Comp comp = {},
      |                                                                     ^
p1153.cpp:1380:71: error: expected unqualified-id before ',' token
 1380 |     constexpr bool binary_search(R&& r, const T& value, Comp comp = {},
      |                                                                       ^
p1153.cpp:1381:39: error: expected constructor, destructor, or type conversion before 'proj'
 1381 |                                  Proj proj = {});
      |                                       ^~~~
p1153.cpp:1381:48: error: expected unqualified-id before ')' token
 1381 |                                  Proj proj = {});
      |                                                ^
p1153.cpp:1385:3: error: 'constexpr' does not name a type
 1385 |   constexpr bool is_partitioned(InputIterator first, InputIterator last, Predicate pred);
      |   ^~~~~~~~~
p1153.cpp:1385:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1387:36: error: expected ',' or '...' before '&&' token
 1387 | bool is_partitioned(ExecutionPolicy&& exec, // see 27.3.5
      |                                    ^~
p1153.cpp:1390:12: error: 'input_iterator' has not been declared
 1390 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~
p1153.cpp:1390:30: error: 'sentinel_for' has not been declared
 1390 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                              ^~~~~~~~~~~~
p1153.cpp:1390:42: error: expected '>' before '<' token
 1390 |   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                          ^
p1153.cpp:1392:75: error: expected unqualified-id before '{' token
 1392 |     constexpr bool is_partitioned(I first, S last, Pred pred, Proj proj = {});
      |                                                                           ^
p1153.cpp:1392:77: error: expected unqualified-id before ')' token
 1392 |     constexpr bool is_partitioned(I first, S last, Pred pred, Proj proj = {});
      |                                                                             ^
p1153.cpp:1393:12: error: 'input_range' has not been declared
 1393 |   template<input_range R, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:1393:40: error: 'identity' does not name a type
 1393 |   template<input_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1153.cpp:1394:12: error: 'indirect_unary_predicate' has not been declared
 1394 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1394:36: error: expected '>' before '<' token
 1394 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                    ^
p1153.cpp:1395:65: error: expected unqualified-id before '{' token
 1395 |     constexpr bool is_partitioned(R&& r, Pred pred, Proj proj = {});
      |                                                                 ^
p1153.cpp:1395:67: error: expected unqualified-id before ')' token
 1395 |     constexpr bool is_partitioned(R&& r, Pred pred, Proj proj = {});
      |                                                                   ^
p1153.cpp:1398:3: error: 'constexpr' does not name a type
 1398 |   constexpr ForwardIterator partition(ForwardIterator first,
      |   ^~~~~~~~~
p1153.cpp:1398:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1402:42: error: expected ',' or '...' before '&&' token
 1402 | ForwardIterator partition(ExecutionPolicy&& exec, // see 27.3.5
      |                                          ^~
p1153.cpp:1407:12: error: 'permutable' has not been declared
 1407 |   template<permutable I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~
p1153.cpp:1407:26: error: 'sentinel_for' has not been declared
 1407 |   template<permutable I, sentinel_for<I> S, class Proj = identity,
      |                          ^~~~~~~~~~~~
p1153.cpp:1407:38: error: expected '>' before '<' token
 1407 |   template<permutable I, sentinel_for<I> S, class Proj = identity,
      |                                      ^
p1153.cpp:1410:51: error: expected unqualified-id before '{' token
 1410 | partition(I first, S last, Pred pred, Proj proj = {});
      |                                                   ^
p1153.cpp:1410:53: error: expected unqualified-id before ')' token
 1410 | partition(I first, S last, Pred pred, Proj proj = {});
      |                                                     ^
p1153.cpp:1411:12: error: 'forward_range' has not been declared
 1411 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1411:42: error: 'identity' does not name a type
 1411 |   template<forward_range R, class Proj = identity,
      |                                          ^~~~~~~~
p1153.cpp:1412:12: error: 'indirect_unary_predicate' has not been declared
 1412 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1412:36: error: expected '>' before '<' token
 1412 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                    ^
p1153.cpp:1415:47: error: expected unqualified-id before '{' token
 1415 |       partition(R&& r, Pred pred, Proj proj = {});
      |                                               ^
p1153.cpp:1415:49: error: expected unqualified-id before ')' token
 1415 |       partition(R&& r, Pred pred, Proj proj = {});
      |                                                 ^
p1153.cpp:1422:55: error: expected ',' or '...' before '&&' token
 1422 | BidirectionalIterator stable_partition(ExecutionPolicy&& exec, // see // 27.3.5
      |                                                       ^~
p1153.cpp:1427:12: error: 'bidirectional_iterator' has not been declared
 1427 |   template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1427:38: error: 'sentinel_for' has not been declared
 1427 |   template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                      ^~~~~~~~~~~~
p1153.cpp:1427:50: error: expected '>' before '<' token
 1427 |   template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                                  ^
p1153.cpp:1430:74: error: expected unqualified-id before '{' token
 1430 |     subrange<I> stable_partition(I first, S last, Pred pred, Proj proj = {});
      |                                                                          ^
p1153.cpp:1430:76: error: expected unqualified-id before ')' token
 1430 |     subrange<I> stable_partition(I first, S last, Pred pred, Proj proj = {});
      |                                                                            ^
p1153.cpp:1431:12: error: 'bidirectional_range' has not been declared
 1431 |   template<bidirectional_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1431:48: error: 'identity' does not name a type
 1431 |   template<bidirectional_range R, class Proj = identity,
      |                                                ^~~~~~~~
p1153.cpp:1432:12: error: 'indirect_unary_predicate' has not been declared
 1432 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1432:36: error: expected '>' before '<' token
 1432 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                    ^
p1153.cpp:1434:75: error: expected unqualified-id before '{' token
 1434 |     borrowed_subrange_t<R> stable_partition(R&& r, Pred pred, Proj proj = {});
      |                                                                           ^
p1153.cpp:1434:77: error: expected unqualified-id before ')' token
 1434 |     borrowed_subrange_t<R> stable_partition(R&& r, Pred pred, Proj proj = {});
      |                                                                             ^
p1153.cpp:1438:3: error: 'constexpr' does not name a type
 1438 |   constexpr pair<OutputIterator1, OutputIterator2>
      |   ^~~~~~~~~
p1153.cpp:1438:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1445:31: error: expected ',' or '...' before '&&' token
 1445 | partition_copy(ExecutionPolicy&& exec, // see 27.3.5
      |                               ^~
p1153.cpp:1451:5: error: expected unqualified-id before 'using'
 1451 |     using partition_copy_result = in_out_out_result<I, O1, O2>;
      |     ^~~~~
p1153.cpp:1452:12: error: 'input_iterator' has not been declared
 1452 |   template<input_iterator I, sentinel_for<I> S,
      |            ^~~~~~~~~~~~~~
p1153.cpp:1452:30: error: 'sentinel_for' has not been declared
 1452 |   template<input_iterator I, sentinel_for<I> S,
      |                              ^~~~~~~~~~~~
p1153.cpp:1452:42: error: expected '>' before '<' token
 1452 |   template<input_iterator I, sentinel_for<I> S,
      |                                          ^
p1153.cpp:1458:34: error: expected unqualified-id before '{' token
 1458 |                      Proj proj = {});
      |                                  ^
p1153.cpp:1458:36: error: expected unqualified-id before ')' token
 1458 |                      Proj proj = {});
      |                                    ^
p1153.cpp:1459:12: error: 'input_range' has not been declared
 1459 |   template<input_range R, weakly_incrementable O1, weakly_incrementable O2,
      |            ^~~~~~~~~~~
p1153.cpp:1459:27: error: 'weakly_incrementable' has not been declared
 1459 |   template<input_range R, weakly_incrementable O1, weakly_incrementable O2,
      |                           ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:1459:52: error: 'weakly_incrementable' has not been declared
 1459 |   template<input_range R, weakly_incrementable O1, weakly_incrementable O2,
      |                                                    ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:1460:25: error: 'identity' does not name a type
 1460 |            class Proj = identity,
      |                         ^~~~~~~~
p1153.cpp:1461:12: error: 'indirect_unary_predicate' has not been declared
 1461 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1461:36: error: expected '>' before '<' token
 1461 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                    ^
p1153.cpp:1465:1: error: expected unqualified-id before '}' token
 1465 | }
      | ^
p1153.cpp:1466:15: error: expected constructor, destructor, or type conversion before '(' token
 1466 | partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
      |               ^
p1153.cpp:1466:75: error: expected unqualified-id before ')' token
 1466 | partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
      |                                                                           ^
p1153.cpp:1468:3: error: 'constexpr' does not name a type
 1468 |   constexpr ForwardIterator
      |   ^~~~~~~~~
p1153.cpp:1468:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1472:12: error: 'forward_iterator' has not been declared
 1472 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:1472:32: error: 'sentinel_for' has not been declared
 1472 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                ^~~~~~~~~~~~
p1153.cpp:1472:44: error: expected '>' before '<' token
 1472 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                            ^
p1153.cpp:1474:73: error: expected unqualified-id before '{' token
 1474 |     constexpr I partition_point(I first, S last, Pred pred, Proj proj = {});
      |                                                                         ^
p1153.cpp:1474:75: error: expected unqualified-id before ')' token
 1474 |     constexpr I partition_point(I first, S last, Pred pred, Proj proj = {});
      |                                                                           ^
p1153.cpp:1475:12: error: 'forward_range' has not been declared
 1475 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1475:42: error: 'identity' does not name a type
 1475 |   template<forward_range R, class Proj = identity,
      |                                          ^~~~~~~~
p1153.cpp:1476:12: error: 'indirect_unary_predicate' has not been declared
 1476 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1476:36: error: expected '>' before '<' token
 1476 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                    ^
p1153.cpp:1478:53: error: expected unqualified-id before '{' token
 1478 |       partition_point(R&& r, Pred pred, Proj proj = {});
      |                                                     ^
p1153.cpp:1478:55: error: expected unqualified-id before ')' token
 1478 |       partition_point(R&& r, Pred pred, Proj proj = {});
      |                                                       ^
p1153.cpp:1482:3: error: 'constexpr' does not name a type
 1482 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:1482:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1488:3: error: 'constexpr' does not name a type
 1488 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:1488:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1495:24: error: expected ',' or '...' before '&&' token
 1495 |   merge(ExecutionPolicy&& exec,
      |                        ^~
p1153.cpp:1503:26: error: expected ',' or '...' before '&&' token
 1503 |     merge(ExecutionPolicy&& exec,
      |                          ^~
p1153.cpp:1509:5: error: expected unqualified-id before 'using'
 1509 |     using merge_result = in_in_out_result<I1, I2, O>;
      |     ^~~~~
p1153.cpp:1512:10: error: 'input_iterator' has not been declared
 1512 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |          ^~~~~~~~~~~~~~
p1153.cpp:1512:29: error: 'sentinel_for' has not been declared
 1512 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                             ^~~~~~~~~~~~
p1153.cpp:1512:41: error: expected '>' before '<' token
 1512 | template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                         ^
p1153.cpp:1515:3: error: 'requires' does not name a type
 1515 |   requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
      |   ^~~~~~~~
p1153.cpp:1515:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1518:25: error: expected unqualified-id before ',' token
 1518 |           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                         ^
p1153.cpp:1518:33: error: expected constructor, destructor, or type conversion before 'proj1'
 1518 |           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                 ^~~~~
p1153.cpp:1518:43: error: expected unqualified-id before ',' token
 1518 |           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                           ^
p1153.cpp:1518:51: error: expected constructor, destructor, or type conversion before 'proj2'
 1518 |           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^~~~~
p1153.cpp:1518:61: error: expected unqualified-id before ')' token
 1518 |           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                             ^
p1153.cpp:1519:10: error: 'input_range' has not been declared
 1519 | template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
      |          ^~~~~~~~~~~
p1153.cpp:1519:26: error: 'input_range' has not been declared
 1519 | template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
      |                          ^~~~~~~~~~~
p1153.cpp:1519:42: error: 'weakly_incrementable' has not been declared
 1519 | template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
      |                                          ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:1519:87: error: 'less' in namespace 'ranges::ranges' does not name a type
 1519 | template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
      |                                                                                       ^~~~
p1153.cpp:1520:24: error: 'identity' does not name a type
 1520 |          class Proj1 = identity, class Proj2 = identity>
      |                        ^~~~~~~~
p1153.cpp:1520:48: error: 'identity' does not name a type
 1520 |          class Proj1 = identity, class Proj2 = identity>
      |                                                ^~~~~~~~
p1153.cpp:1521:3: error: 'requires' does not name a type
 1521 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |   ^~~~~~~~
p1153.cpp:1521:3: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1524:21: error: expected unqualified-id before ',' token
 1524 |       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                     ^
p1153.cpp:1524:29: error: expected constructor, destructor, or type conversion before 'proj1'
 1524 |       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                             ^~~~~
p1153.cpp:1524:39: error: expected unqualified-id before ',' token
 1524 |       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                       ^
p1153.cpp:1524:47: error: expected constructor, destructor, or type conversion before 'proj2'
 1524 |       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                               ^~~~~
p1153.cpp:1524:57: error: expected unqualified-id before ')' token
 1524 |       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                         ^
p1153.cpp:1534:35: error: expected ',' or '...' before '&&' token
 1534 | void inplace_merge(ExecutionPolicy&& exec, // see 27.3.5
      |                                   ^~
p1153.cpp:1539:35: error: expected ',' or '...' before '&&' token
 1539 | void inplace_merge(ExecutionPolicy&& exec, // see 27.3.5
      |                                   ^~
p1153.cpp:1544:12: error: 'bidirectional_iterator' has not been declared
 1544 |   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1544:38: error: 'sentinel_for' has not been declared
 1544 |   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                      ^~~~~~~~~~~~
p1153.cpp:1544:50: error: expected '>' before '<' token
 1544 |   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                  ^
p1153.cpp:1546:5: error: 'requires' does not name a type
 1546 |     requires sortable<I, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1546:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1547:62: error: expected unqualified-id before ',' token
 1547 |     I inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});
      |                                                              ^
p1153.cpp:1547:69: error: expected constructor, destructor, or type conversion before 'proj'
 1547 |     I inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});
      |                                                                     ^~~~
p1153.cpp:1547:78: error: expected unqualified-id before ')' token
 1547 |     I inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});
      |                                                                              ^
p1153.cpp:1548:12: error: 'bidirectional_range' has not been declared
 1548 |   template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1548:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 1548 |   template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
      |                                                        ^~~~
p1153.cpp:1548:75: error: 'identity' does not name a type
 1548 |   template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
      |                                                                           ^~~~~~~~
p1153.cpp:1549:5: error: 'requires' does not name a type
 1549 |     requires sortable<iterator_t<R>, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1549:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1551:64: error: expected unqualified-id before ',' token
 1551 |       inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {},
      |                                                                ^
p1153.cpp:1552:26: error: expected constructor, destructor, or type conversion before 'proj'
 1552 |                     Proj proj = {});
      |                          ^~~~
p1153.cpp:1552:35: error: expected unqualified-id before ')' token
 1552 |                     Proj proj = {});
      |                                   ^
p1153.cpp:1556:3: error: 'constexpr' does not name a type
 1556 |   constexpr bool includes(InputIterator1 first1, InputIterator1 last1,
      |   ^~~~~~~~~
p1153.cpp:1556:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1559:3: error: 'constexpr' does not name a type
 1559 |   constexpr bool includes(InputIterator1 first1, InputIterator1 last1,
      |   ^~~~~~~~~
p1153.cpp:1559:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1563:30: error: expected ',' or '...' before '&&' token
 1563 | bool includes(ExecutionPolicy&& exec, // see 27.3.5
      |                              ^~
p1153.cpp:1568:30: error: expected ',' or '...' before '&&' token
 1568 | bool includes(ExecutionPolicy&& exec, // see 27.3.5
      |                              ^~
p1153.cpp:1573:12: error: 'input_iterator' has not been declared
 1573 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |            ^~~~~~~~~~~~~~
p1153.cpp:1573:31: error: 'sentinel_for' has not been declared
 1573 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                               ^~~~~~~~~~~~
p1153.cpp:1573:43: error: expected '>' before '<' token
 1573 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                           ^
p1153.cpp:1577:83: error: expected unqualified-id before '{' token
 1577 |     constexpr bool includes(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {},
      |                                                                                   ^
p1153.cpp:1577:85: error: expected unqualified-id before ',' token
 1577 |     constexpr bool includes(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {},
      |                                                                                     ^
p1153.cpp:1578:35: error: expected constructor, destructor, or type conversion before 'proj1'
 1578 |                             Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                   ^~~~~
p1153.cpp:1578:45: error: expected unqualified-id before ',' token
 1578 |                             Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                             ^
p1153.cpp:1578:53: error: expected constructor, destructor, or type conversion before 'proj2'
 1578 |                             Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                     ^~~~~
p1153.cpp:1578:63: error: expected unqualified-id before ')' token
 1578 |                             Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                               ^
p1153.cpp:1579:12: error: 'input_range' has not been declared
 1579 |   template<input_range R1, input_range R2, class Proj1 = identity,
      |            ^~~~~~~~~~~
p1153.cpp:1579:28: error: 'input_range' has not been declared
 1579 |   template<input_range R1, input_range R2, class Proj1 = identity,
      |                            ^~~~~~~~~~~
p1153.cpp:1579:58: error: 'identity' does not name a type
 1579 |   template<input_range R1, input_range R2, class Proj1 = identity,
      |                                                          ^~~~~~~~
p1153.cpp:1580:26: error: 'identity' does not name a type
 1580 |            class Proj2 = identity,
      |                          ^~~~~~~~
p1153.cpp:1581:12: error: 'indirect_strict_weak_order' has not been declared
 1581 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1581:38: error: expected '>' before '<' token
 1581 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                      ^
p1153.cpp:1583:59: error: expected unqualified-id before '{' token
 1583 |     constexpr bool includes(R1&& r1, R2&& r2, Comp comp = {},
      |                                                           ^
p1153.cpp:1583:61: error: expected unqualified-id before ',' token
 1583 |     constexpr bool includes(R1&& r1, R2&& r2, Comp comp = {},
      |                                                             ^
p1153.cpp:1584:1: error: expected unqualified-id before '}' token
 1584 | }
      | ^
p1153.cpp:1585:1: error: 'Proj1' does not name a type
 1585 | Proj1 proj1 = {}, Proj2 proj2 = {});
      | ^~~~~
p1153.cpp:1585:17: error: expected unqualified-id before ',' token
 1585 | Proj1 proj1 = {}, Proj2 proj2 = {});
      |                 ^
p1153.cpp:1585:25: error: expected constructor, destructor, or type conversion before 'proj2'
 1585 | Proj1 proj1 = {}, Proj2 proj2 = {});
      |                         ^~~~~
p1153.cpp:1585:35: error: expected unqualified-id before ')' token
 1585 | Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                   ^
p1153.cpp:1587:3: error: 'constexpr' does not name a type
 1587 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:1587:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1592:3: error: 'constexpr' does not name a type
 1592 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:1592:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1599:26: error: expected ',' or '...' before '&&' token
 1599 | set_union(ExecutionPolicy&& exec, // see 27.3.5
      |                          ^~
p1153.cpp:1606:26: error: expected ',' or '...' before '&&' token
 1606 | set_union(ExecutionPolicy&& exec, // see 27.3.5
      |                          ^~
p1153.cpp:1612:5: error: expected unqualified-id before 'using'
 1612 |     using set_union_result = in_in_out_result<I1, I2, O>;
      |     ^~~~~
p1153.cpp:1613:12: error: 'input_iterator' has not been declared
 1613 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |            ^~~~~~~~~~~~~~
p1153.cpp:1613:31: error: 'sentinel_for' has not been declared
 1613 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                               ^~~~~~~~~~~~
p1153.cpp:1613:43: error: expected '>' before '<' token
 1613 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                           ^
p1153.cpp:1616:5: error: 'requires' does not name a type
 1616 |     requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:1616:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1618:83: error: expected unqualified-id before ',' token
 1618 |       set_union(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {},
      |                                                                                   ^
p1153.cpp:1619:23: error: expected constructor, destructor, or type conversion before 'proj1'
 1619 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                       ^~~~~
p1153.cpp:1619:33: error: expected unqualified-id before ',' token
 1619 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                 ^
p1153.cpp:1619:41: error: expected constructor, destructor, or type conversion before 'proj2'
 1619 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                         ^~~~~
p1153.cpp:1619:51: error: expected unqualified-id before ')' token
 1619 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^
p1153.cpp:1620:12: error: 'input_range' has not been declared
 1620 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |            ^~~~~~~~~~~
p1153.cpp:1620:28: error: 'input_range' has not been declared
 1620 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |                            ^~~~~~~~~~~
p1153.cpp:1620:44: error: 'weakly_incrementable' has not been declared
 1620 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |                                            ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:1621:33: error: 'less' in namespace 'ranges::ranges' does not name a type
 1621 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                 ^~~~
p1153.cpp:1621:53: error: 'identity' does not name a type
 1621 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                                     ^~~~~~~~
p1153.cpp:1621:77: error: 'identity' does not name a type
 1621 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                                                             ^~~~~~~~
p1153.cpp:1622:5: error: 'requires' does not name a type
 1622 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:1622:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1624:59: error: expected unqualified-id before ',' token
 1624 |       set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
      |                                                           ^
p1153.cpp:1625:23: error: expected constructor, destructor, or type conversion before 'proj1'
 1625 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                       ^~~~~
p1153.cpp:1625:33: error: expected unqualified-id before ',' token
 1625 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                 ^
p1153.cpp:1625:41: error: expected constructor, destructor, or type conversion before 'proj2'
 1625 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                         ^~~~~
p1153.cpp:1625:51: error: expected unqualified-id before ')' token
 1625 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^
p1153.cpp:1628:3: error: 'constexpr' does not name a type
 1628 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:1628:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1633:3: error: 'constexpr' does not name a type
 1633 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:1633:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1640:33: error: expected ',' or '...' before '&&' token
 1640 | set_intersection(ExecutionPolicy&& exec, // see 27.3.5
      |                                 ^~
p1153.cpp:1646:33: error: expected ',' or '...' before '&&' token
 1646 | set_intersection(ExecutionPolicy&& exec, // see 27.3.5
      |                                 ^~
p1153.cpp:1651:5: error: expected unqualified-id before 'using'
 1651 |     using set_intersection_result = in_in_out_result<I1, I2, O>;
      |     ^~~~~
p1153.cpp:1652:12: error: 'input_iterator' has not been declared
 1652 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |            ^~~~~~~~~~~~~~
p1153.cpp:1652:31: error: 'sentinel_for' has not been declared
 1652 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                               ^~~~~~~~~~~~
p1153.cpp:1652:43: error: expected '>' before '<' token
 1652 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                           ^
p1153.cpp:1655:5: error: 'requires' does not name a type
 1655 |     requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:1655:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1658:38: error: expected unqualified-id before ',' token
 1658 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                      ^
p1153.cpp:1658:46: error: expected constructor, destructor, or type conversion before 'proj1'
 1658 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                              ^~~~~
p1153.cpp:1658:56: error: expected unqualified-id before ',' token
 1658 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                        ^
p1153.cpp:1658:64: error: expected constructor, destructor, or type conversion before 'proj2'
 1658 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                ^~~~~
p1153.cpp:1658:74: error: expected unqualified-id before ')' token
 1658 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                          ^
p1153.cpp:1659:12: error: 'input_range' has not been declared
 1659 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |            ^~~~~~~~~~~
p1153.cpp:1659:28: error: 'input_range' has not been declared
 1659 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |                            ^~~~~~~~~~~
p1153.cpp:1659:44: error: 'weakly_incrementable' has not been declared
 1659 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |                                            ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:1660:33: error: 'less' in namespace 'ranges::ranges' does not name a type
 1660 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                 ^~~~
p1153.cpp:1660:53: error: 'identity' does not name a type
 1660 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                                     ^~~~~~~~
p1153.cpp:1660:77: error: 'identity' does not name a type
 1660 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                                                             ^~~~~~~~
p1153.cpp:1661:5: error: 'requires' does not name a type
 1661 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:1661:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1664:38: error: expected unqualified-id before ',' token
 1664 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                      ^
p1153.cpp:1664:46: error: expected constructor, destructor, or type conversion before 'proj1'
 1664 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                              ^~~~~
p1153.cpp:1664:56: error: expected unqualified-id before ',' token
 1664 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                        ^
p1153.cpp:1664:64: error: expected constructor, destructor, or type conversion before 'proj2'
 1664 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                ^~~~~
p1153.cpp:1664:74: error: expected unqualified-id before ')' token
 1664 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                          ^
p1153.cpp:1667:3: error: 'constexpr' does not name a type
 1667 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:1667:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1672:3: error: 'constexpr' does not name a type
 1672 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:1672:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1679:31: error: expected ',' or '...' before '&&' token
 1679 | set_difference(ExecutionPolicy&& exec, // see 27.3.5
      |                               ^~
p1153.cpp:1685:31: error: expected ',' or '...' before '&&' token
 1685 | set_difference(ExecutionPolicy&& exec, // see 27.3.5
      |                               ^~
p1153.cpp:1690:5: error: expected unqualified-id before 'using'
 1690 |     using set_difference_result = in_out_result<I, O>;
      |     ^~~~~
p1153.cpp:1691:12: error: 'input_iterator' has not been declared
 1691 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |            ^~~~~~~~~~~~~~
p1153.cpp:1691:31: error: 'sentinel_for' has not been declared
 1691 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                               ^~~~~~~~~~~~
p1153.cpp:1691:43: error: expected '>' before '<' token
 1691 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                           ^
p1153.cpp:1694:5: error: 'requires' does not name a type
 1694 |     requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:1694:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1697:36: error: expected unqualified-id before ',' token
 1697 |                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                    ^
p1153.cpp:1697:44: error: expected constructor, destructor, or type conversion before 'proj1'
 1697 |                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                            ^~~~~
p1153.cpp:1697:54: error: expected unqualified-id before ',' token
 1697 |                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                      ^
p1153.cpp:1697:62: error: expected constructor, destructor, or type conversion before 'proj2'
 1697 |                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                              ^~~~~
p1153.cpp:1697:72: error: expected unqualified-id before ')' token
 1697 |                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                        ^
p1153.cpp:1698:12: error: 'input_range' has not been declared
 1698 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |            ^~~~~~~~~~~
p1153.cpp:1698:28: error: 'input_range' has not been declared
 1698 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |                            ^~~~~~~~~~~
p1153.cpp:1698:44: error: 'weakly_incrementable' has not been declared
 1698 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |                                            ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:1699:33: error: 'less' in namespace 'ranges::ranges' does not name a type
 1699 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                 ^~~~
p1153.cpp:1699:53: error: 'identity' does not name a type
 1699 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                                     ^~~~~~~~
p1153.cpp:1699:77: error: 'identity' does not name a type
 1699 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                                                             ^~~~~~~~
p1153.cpp:1700:5: error: 'requires' does not name a type
 1700 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:1700:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1704:15: error: expected constructor, destructor, or type conversion before '(' token
 1704 | set_difference(R1&& r1, R2&& r2, O result,
      |               ^
p1153.cpp:1705:30: error: expected unqualified-id before ',' token
 1705 |                Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                              ^
p1153.cpp:1705:38: error: expected constructor, destructor, or type conversion before 'proj1'
 1705 |                Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                      ^~~~~
p1153.cpp:1705:48: error: expected unqualified-id before ',' token
 1705 |                Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                ^
p1153.cpp:1705:56: error: expected constructor, destructor, or type conversion before 'proj2'
 1705 |                Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                        ^~~~~
p1153.cpp:1705:66: error: expected unqualified-id before ')' token
 1705 |                Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                  ^
p1153.cpp:1707:3: error: 'constexpr' does not name a type
 1707 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:1707:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1712:3: error: 'constexpr' does not name a type
 1712 |   constexpr OutputIterator
      |   ^~~~~~~~~
p1153.cpp:1712:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1719:41: error: expected ',' or '...' before '&&' token
 1719 | set_symmetric_difference(ExecutionPolicy&& exec, // see 27.3.5
      |                                         ^~
p1153.cpp:1725:41: error: expected ',' or '...' before '&&' token
 1725 | set_symmetric_difference(ExecutionPolicy&& exec, // see 27.3.5
      |                                         ^~
p1153.cpp:1730:5: error: expected unqualified-id before 'using'
 1730 |     using set_symmetric_difference_result = in_in_out_result<I1, I2, O>;
      |     ^~~~~
p1153.cpp:1731:12: error: 'input_iterator' has not been declared
 1731 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |            ^~~~~~~~~~~~~~
p1153.cpp:1731:31: error: 'sentinel_for' has not been declared
 1731 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                               ^~~~~~~~~~~~
p1153.cpp:1731:43: error: expected '>' before '<' token
 1731 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                           ^
p1153.cpp:1734:5: error: 'requires' does not name a type
 1734 |     requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:1734:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1737:46: error: expected unqualified-id before ',' token
 1737 |                                Comp comp = {}, Proj1 proj1 = {},
      |                                              ^
p1153.cpp:1737:54: error: expected constructor, destructor, or type conversion before 'proj1'
 1737 |                                Comp comp = {}, Proj1 proj1 = {},
      |                                                      ^~~~~
p1153.cpp:1737:64: error: expected unqualified-id before ',' token
 1737 |                                Comp comp = {}, Proj1 proj1 = {},
      |                                                                ^
p1153.cpp:1738:38: error: expected constructor, destructor, or type conversion before 'proj2'
 1738 |                                Proj2 proj2 = {});
      |                                      ^~~~~
p1153.cpp:1738:48: error: expected unqualified-id before ')' token
 1738 |                                Proj2 proj2 = {});
      |                                                ^
p1153.cpp:1739:12: error: 'input_range' has not been declared
 1739 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |            ^~~~~~~~~~~
p1153.cpp:1739:28: error: 'input_range' has not been declared
 1739 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |                            ^~~~~~~~~~~
p1153.cpp:1739:44: error: 'weakly_incrementable' has not been declared
 1739 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |                                            ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:1740:33: error: 'less' in namespace 'ranges::ranges' does not name a type
 1740 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                 ^~~~
p1153.cpp:1740:53: error: 'identity' does not name a type
 1740 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                                     ^~~~~~~~
p1153.cpp:1740:77: error: 'identity' does not name a type
 1740 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                                                             ^~~~~~~~
p1153.cpp:1741:5: error: 'requires' does not name a type
 1741 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |     ^~~~~~~~
p1153.cpp:1741:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1744:68: error: expected unqualified-id before ',' token
 1744 | set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
      |                                                                    ^
p1153.cpp:1745:32: error: expected constructor, destructor, or type conversion before 'proj1'
 1745 |                          Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                ^~~~~
p1153.cpp:1745:42: error: expected unqualified-id before ',' token
 1745 |                          Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                          ^
p1153.cpp:1745:50: error: expected constructor, destructor, or type conversion before 'proj2'
 1745 |                          Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                  ^~~~~
p1153.cpp:1745:60: error: expected unqualified-id before ')' token
 1745 |                          Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                            ^
p1153.cpp:1748:3: error: 'constexpr' does not name a type
 1748 |   constexpr void push_heap(RandomAccessIterator first, RandomAccessIterator last);
      |   ^~~~~~~~~
p1153.cpp:1748:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1750:3: error: 'constexpr' does not name a type
 1750 |   constexpr void push_heap(RandomAccessIterator first, RandomAccessIterator last,
      |   ^~~~~~~~~
p1153.cpp:1750:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1753:12: error: 'random_access_iterator' has not been declared
 1753 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1753:38: error: 'sentinel_for' has not been declared
 1753 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                      ^~~~~~~~~~~~
p1153.cpp:1753:50: error: expected '>' before '<' token
 1753 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                  ^
p1153.cpp:1755:5: error: 'requires' does not name a type
 1755 |     requires sortable<I, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1755:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1757:48: error: expected unqualified-id before ',' token
 1757 |       push_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                ^
p1153.cpp:1757:55: error: expected constructor, destructor, or type conversion before 'proj'
 1757 |       push_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                       ^~~~
p1153.cpp:1757:64: error: expected unqualified-id before ')' token
 1757 |       push_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                ^
p1153.cpp:1758:12: error: 'random_access_range' has not been declared
 1758 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1758:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 1758 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                        ^~~~
p1153.cpp:1758:75: error: 'identity' does not name a type
 1758 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                                           ^~~~~~~~
p1153.cpp:1759:5: error: 'requires' does not name a type
 1759 |     requires sortable<iterator_t<R>, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1759:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1761:38: error: expected unqualified-id before ',' token
 1761 |       push_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                      ^
p1153.cpp:1761:45: error: expected constructor, destructor, or type conversion before 'proj'
 1761 |       push_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                             ^~~~
p1153.cpp:1761:54: error: expected unqualified-id before ')' token
 1761 |       push_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                      ^
p1153.cpp:1764:3: error: 'constexpr' does not name a type
 1764 |   constexpr void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
      |   ^~~~~~~~~
p1153.cpp:1764:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1766:3: error: 'constexpr' does not name a type
 1766 |   constexpr void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
      |   ^~~~~~~~~
p1153.cpp:1766:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1769:12: error: 'random_access_iterator' has not been declared
 1769 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1769:38: error: 'sentinel_for' has not been declared
 1769 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                      ^~~~~~~~~~~~
p1153.cpp:1769:50: error: expected '>' before '<' token
 1769 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                  ^
p1153.cpp:1771:5: error: 'requires' does not name a type
 1771 |     requires sortable<I, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1771:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1773:47: error: expected unqualified-id before ',' token
 1773 |       pop_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                               ^
p1153.cpp:1773:54: error: expected constructor, destructor, or type conversion before 'proj'
 1773 |       pop_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                      ^~~~
p1153.cpp:1773:63: error: expected unqualified-id before ')' token
 1773 |       pop_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                               ^
p1153.cpp:1774:12: error: 'random_access_range' has not been declared
 1774 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1774:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 1774 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                        ^~~~
p1153.cpp:1774:75: error: 'identity' does not name a type
 1774 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                                           ^~~~~~~~
p1153.cpp:1775:5: error: 'requires' does not name a type
 1775 |     requires sortable<iterator_t<R>, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1775:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1777:37: error: expected unqualified-id before ',' token
 1777 |       pop_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                     ^
p1153.cpp:1777:44: error: expected constructor, destructor, or type conversion before 'proj'
 1777 |       pop_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                            ^~~~
p1153.cpp:1777:53: error: expected unqualified-id before ')' token
 1777 |       pop_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                     ^
p1153.cpp:1780:3: error: 'constexpr' does not name a type
 1780 |   constexpr void make_heap(RandomAccessIterator first, RandomAccessIterator last);
      |   ^~~~~~~~~
p1153.cpp:1780:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1782:3: error: 'constexpr' does not name a type
 1782 |   constexpr void make_heap(RandomAccessIterator first, RandomAccessIterator last,
      |   ^~~~~~~~~
p1153.cpp:1782:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1785:12: error: 'random_access_iterator' has not been declared
 1785 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1785:38: error: 'sentinel_for' has not been declared
 1785 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                      ^~~~~~~~~~~~
p1153.cpp:1785:50: error: expected '>' before '<' token
 1785 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                  ^
p1153.cpp:1787:5: error: 'requires' does not name a type
 1787 |     requires sortable<I, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1787:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1789:48: error: expected unqualified-id before ',' token
 1789 |       make_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                ^
p1153.cpp:1789:55: error: expected constructor, destructor, or type conversion before 'proj'
 1789 |       make_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                       ^~~~
p1153.cpp:1789:64: error: expected unqualified-id before ')' token
 1789 |       make_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                ^
p1153.cpp:1790:12: error: 'random_access_range' has not been declared
 1790 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1790:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 1790 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                        ^~~~
p1153.cpp:1790:75: error: 'identity' does not name a type
 1790 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                                           ^~~~~~~~
p1153.cpp:1791:5: error: 'requires' does not name a type
 1791 |     requires sortable<iterator_t<R>, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1791:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1793:38: error: expected unqualified-id before ',' token
 1793 |       make_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                      ^
p1153.cpp:1793:45: error: expected constructor, destructor, or type conversion before 'proj'
 1793 |       make_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                             ^~~~
p1153.cpp:1793:54: error: expected unqualified-id before ')' token
 1793 |       make_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                      ^
p1153.cpp:1796:3: error: 'constexpr' does not name a type
 1796 |   constexpr void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
      |   ^~~~~~~~~
p1153.cpp:1796:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1798:3: error: 'constexpr' does not name a type
 1798 |   constexpr void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
      |   ^~~~~~~~~
p1153.cpp:1798:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1801:12: error: 'random_access_iterator' has not been declared
 1801 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1801:38: error: 'sentinel_for' has not been declared
 1801 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                      ^~~~~~~~~~~~
p1153.cpp:1801:50: error: expected '>' before '<' token
 1801 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                  ^
p1153.cpp:1803:5: error: 'requires' does not name a type
 1803 |     requires sortable<I, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1803:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1805:48: error: expected unqualified-id before ',' token
 1805 |       sort_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                ^
p1153.cpp:1805:55: error: expected constructor, destructor, or type conversion before 'proj'
 1805 |       sort_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                       ^~~~
p1153.cpp:1805:64: error: expected unqualified-id before ')' token
 1805 |       sort_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                ^
p1153.cpp:1806:12: error: 'random_access_range' has not been declared
 1806 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1806:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 1806 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                        ^~~~
p1153.cpp:1806:75: error: 'identity' does not name a type
 1806 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                                           ^~~~~~~~
p1153.cpp:1807:5: error: 'requires' does not name a type
 1807 |     requires sortable<iterator_t<R>, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:1807:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:1809:38: error: expected unqualified-id before ',' token
 1809 |       sort_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                      ^
p1153.cpp:1809:45: error: expected constructor, destructor, or type conversion before 'proj'
 1809 |       sort_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                             ^~~~
p1153.cpp:1809:54: error: expected unqualified-id before ')' token
 1809 |       sort_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                      ^
p1153.cpp:1812:3: error: 'constexpr' does not name a type
 1812 |   constexpr bool is_heap(RandomAccessIterator first, RandomAccessIterator last);
      |   ^~~~~~~~~
p1153.cpp:1812:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1814:3: error: 'constexpr' does not name a type
 1814 |   constexpr bool is_heap(RandomAccessIterator first, RandomAccessIterator last,
      |   ^~~~~~~~~
p1153.cpp:1814:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1817:29: error: expected ',' or '...' before '&&' token
 1817 | bool is_heap(ExecutionPolicy&& exec, // see 27.3.5
      |                             ^~
p1153.cpp:1819:104: error: expected ',' or '...' before '&&' token
 1819 | ExecutionPolicy, class RandomAccessIterator, class Compare> bool is_heap(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                         ^~

p1153.cpp:1823:12: error: 'random_access_iterator' has not been declared
 1823 |   template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1823:38: error: 'sentinel_for' has not been declared
 1823 |   template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                      ^~~~~~~~~~~~
p1153.cpp:1823:50: error: expected '>' before '<' token
 1823 |   template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                                  ^
p1153.cpp:1825:57: error: expected unqualified-id before '{' token
 1825 |     constexpr bool is_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                         ^
p1153.cpp:1825:59: error: expected unqualified-id before ',' token
 1825 |     constexpr bool is_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                           ^
p1153.cpp:1825:66: error: expected constructor, destructor, or type conversion before 'proj'
 1825 |     constexpr bool is_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                  ^~~~
p1153.cpp:1825:75: error: expected unqualified-id before ')' token
 1825 |     constexpr bool is_heap(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                           ^
p1153.cpp:1826:12: error: 'random_access_range' has not been declared
 1826 |   template<random_access_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1826:48: error: 'identity' does not name a type
 1826 |   template<random_access_range R, class Proj = identity,
      |                                                ^~~~~~~~
p1153.cpp:1827:12: error: 'indirect_strict_weak_order' has not been declared
 1827 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1827:38: error: expected '>' before '<' token
 1827 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1828:47: error: expected unqualified-id before '{' token
 1828 |     constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                               ^
p1153.cpp:1828:49: error: expected unqualified-id before ',' token
 1828 |     constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                 ^
p1153.cpp:1828:56: error: expected constructor, destructor, or type conversion before 'proj'
 1828 |     constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                        ^~~~
p1153.cpp:1828:65: error: expected unqualified-id before ')' token
 1828 |     constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                                 ^
p1153.cpp:1831:3: error: 'constexpr' does not name a type
 1831 |   constexpr RandomAccessIterator
      |   ^~~~~~~~~
p1153.cpp:1831:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1834:3: error: 'constexpr' does not name a type
 1834 |   constexpr RandomAccessIterator
      |   ^~~~~~~~~
p1153.cpp:1834:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1839:30: error: expected ',' or '...' before '&&' token
 1839 | is_heap_until(ExecutionPolicy&& exec, // see 27.3.5
      |                              ^~
p1153.cpp:1843:30: error: expected ',' or '...' before '&&' token
 1843 | is_heap_until(ExecutionPolicy&& exec, // see 27.3.5
      |                              ^~
p1153.cpp:1847:12: error: 'random_access_iterator' has not been declared
 1847 |   template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1847:38: error: 'sentinel_for' has not been declared
 1847 |   template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                      ^~~~~~~~~~~~
p1153.cpp:1847:50: error: expected '>' before '<' token
 1847 |   template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                                  ^
p1153.cpp:1849:60: error: expected unqualified-id before '{' token
 1849 |     constexpr I is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1153.cpp:1849:62: error: expected unqualified-id before ',' token
 1849 |     constexpr I is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                              ^
p1153.cpp:1849:69: error: expected constructor, destructor, or type conversion before 'proj'
 1849 |     constexpr I is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                     ^~~~
p1153.cpp:1849:78: error: expected unqualified-id before ')' token
 1849 |     constexpr I is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                              ^
p1153.cpp:1850:12: error: 'random_access_range' has not been declared
 1850 |   template<random_access_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1850:48: error: 'identity' does not name a type
 1850 |   template<random_access_range R, class Proj = identity,
      |                                                ^~~~~~~~
p1153.cpp:1851:12: error: 'indirect_strict_weak_order' has not been declared
 1851 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1851:38: error: expected '>' before '<' token
 1851 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1853:40: error: expected unqualified-id before '{' token
 1853 |       is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                        ^
p1153.cpp:1853:42: error: expected unqualified-id before ',' token
 1853 |       is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                          ^
p1153.cpp:1853:49: error: expected constructor, destructor, or type conversion before 'proj'
 1853 |       is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                 ^~~~
p1153.cpp:1853:58: error: expected unqualified-id before ')' token
 1853 |       is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                          ^
p1153.cpp:1856:19: error: 'constexpr' does not name a type
 1856 | template<class T> constexpr const T& min(const T& a, const T& b); template<class T, class Compare>
      |                   ^~~~~~~~~
p1153.cpp:1856:19: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1857:3: error: 'constexpr' does not name a type
 1857 |   constexpr const T& min(const T& a, const T& b, Compare comp);
      |   ^~~~~~~~~
p1153.cpp:1857:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1859:3: error: 'constexpr' does not name a type
 1859 |   constexpr T min(initializer_list<T> t);
      |   ^~~~~~~~~
p1153.cpp:1859:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1861:3: error: 'constexpr' does not name a type
 1861 |   constexpr T min(initializer_list<T> t, Compare comp);
      |   ^~~~~~~~~
p1153.cpp:1861:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1863:34: error: 'identity' does not name a type
 1863 |   template<class T, class Proj = identity,
      |                                  ^~~~~~~~
p1153.cpp:1864:12: error: 'indirect_strict_weak_order' has not been declared
 1864 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1864:38: error: expected '>' before '<' token
 1864 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1865:64: error: expected unqualified-id before '{' token
 1865 |     constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                ^
p1153.cpp:1865:66: error: expected unqualified-id before ',' token
 1865 |     constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                  ^
p1153.cpp:1865:73: error: expected constructor, destructor, or type conversion before 'proj'
 1865 |     constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                         ^~~~
p1153.cpp:1865:82: error: expected unqualified-id before ')' token
 1865 |     constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                                  ^
p1153.cpp:1866:12: error: 'copyable' has not been declared
 1866 |   template<copyable T, class Proj = identity,
      |            ^~~~~~~~
p1153.cpp:1866:37: error: 'identity' does not name a type
 1866 |   template<copyable T, class Proj = identity,
      |                                     ^~~~~~~~
p1153.cpp:1867:12: error: 'indirect_strict_weak_order' has not been declared
 1867 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1867:38: error: expected '>' before '<' token
 1867 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1868:56: error: expected unqualified-id before '{' token
 1868 |     constexpr T min(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                        ^
p1153.cpp:1868:58: error: expected unqualified-id before ',' token
 1868 |     constexpr T min(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                          ^
p1153.cpp:1868:65: error: expected constructor, destructor, or type conversion before 'proj'
 1868 |     constexpr T min(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                 ^~~~
p1153.cpp:1868:74: error: expected unqualified-id before ')' token
 1868 |     constexpr T min(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                          ^
p1153.cpp:1869:12: error: 'input_range' has not been declared
 1869 |   template<input_range R, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:1869:40: error: 'identity' does not name a type
 1869 |   template<input_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1153.cpp:1870:12: error: 'indirect_strict_weak_order' has not been declared
 1870 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1870:38: error: expected '>' before '<' token
 1870 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1873:30: error: expected unqualified-id before '{' token
 1873 |       min(R&& r, Comp comp = {}, Proj proj = {});
      |                              ^
p1153.cpp:1873:32: error: expected unqualified-id before ',' token
 1873 |       min(R&& r, Comp comp = {}, Proj proj = {});
      |                                ^
p1153.cpp:1873:39: error: expected constructor, destructor, or type conversion before 'proj'
 1873 |       min(R&& r, Comp comp = {}, Proj proj = {});
      |                                       ^~~~
p1153.cpp:1873:48: error: expected unqualified-id before ')' token
 1873 |       min(R&& r, Comp comp = {}, Proj proj = {});
      |                                                ^
p1153.cpp:1875:19: error: 'constexpr' does not name a type
 1875 | template<class T> constexpr const T& max(const T& a, const T& b);
      |                   ^~~~~~~~~
p1153.cpp:1875:19: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1877:3: error: 'constexpr' does not name a type
 1877 |   constexpr const T& max(const T& a, const T& b, Compare comp);
      |   ^~~~~~~~~
p1153.cpp:1877:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1879:3: error: 'constexpr' does not name a type
 1879 |   constexpr T max(initializer_list<T> t);
      |   ^~~~~~~~~
p1153.cpp:1879:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1881:3: error: 'constexpr' does not name a type
 1881 |   constexpr T max(initializer_list<T> t, Compare comp);
      |   ^~~~~~~~~
p1153.cpp:1881:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1883:34: error: 'identity' does not name a type
 1883 |   template<class T, class Proj = identity,
      |                                  ^~~~~~~~
p1153.cpp:1884:12: error: 'indirect_strict_weak_order' has not been declared
 1884 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1884:38: error: expected '>' before '<' token
 1884 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1885:64: error: expected unqualified-id before '{' token
 1885 |     constexpr const T& max(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                ^
p1153.cpp:1885:66: error: expected unqualified-id before ',' token
 1885 |     constexpr const T& max(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                  ^
p1153.cpp:1885:73: error: expected constructor, destructor, or type conversion before 'proj'
 1885 |     constexpr const T& max(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                         ^~~~
p1153.cpp:1885:82: error: expected unqualified-id before ')' token
 1885 |     constexpr const T& max(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                                  ^
p1153.cpp:1886:12: error: 'copyable' has not been declared
 1886 |   template<copyable T, class Proj = identity,
      |            ^~~~~~~~
p1153.cpp:1886:37: error: 'identity' does not name a type
 1886 |   template<copyable T, class Proj = identity,
      |                                     ^~~~~~~~
p1153.cpp:1887:12: error: 'indirect_strict_weak_order' has not been declared
 1887 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1887:38: error: expected '>' before '<' token
 1887 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1888:56: error: expected unqualified-id before '{' token
 1888 |     constexpr T max(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                        ^
p1153.cpp:1888:58: error: expected unqualified-id before ',' token
 1888 |     constexpr T max(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                          ^
p1153.cpp:1888:65: error: expected constructor, destructor, or type conversion before 'proj'
 1888 |     constexpr T max(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                 ^~~~
p1153.cpp:1888:74: error: expected unqualified-id before ')' token
 1888 |     constexpr T max(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                          ^
p1153.cpp:1889:12: error: 'input_range' has not been declared
 1889 |   template<input_range R, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:1889:40: error: 'identity' does not name a type
 1889 |   template<input_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1153.cpp:1890:12: error: 'indirect_strict_weak_order' has not been declared
 1890 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1890:38: error: expected '>' before '<' token
 1890 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1893:30: error: expected unqualified-id before '{' token
 1893 |       max(R&& r, Comp comp = {}, Proj proj = {});
      |                              ^
p1153.cpp:1893:32: error: expected unqualified-id before ',' token
 1893 |       max(R&& r, Comp comp = {}, Proj proj = {});
      |                                ^
p1153.cpp:1893:39: error: expected constructor, destructor, or type conversion before 'proj'
 1893 |       max(R&& r, Comp comp = {}, Proj proj = {});
      |                                       ^~~~
p1153.cpp:1893:48: error: expected unqualified-id before ')' token
 1893 |       max(R&& r, Comp comp = {}, Proj proj = {});
      |                                                ^
p1153.cpp:1895:19: error: 'constexpr' does not name a type
 1895 | template<class T> constexpr pair<const T&, const T&> minmax(const T& a, const T& b);
      |                   ^~~~~~~~~
p1153.cpp:1895:19: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1897:3: error: 'constexpr' does not name a type
 1897 |   constexpr pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
      |   ^~~~~~~~~
p1153.cpp:1897:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1899:3: error: 'constexpr' does not name a type
 1899 |   constexpr pair<T, T> minmax(initializer_list<T> t);
      |   ^~~~~~~~~
p1153.cpp:1899:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1901:3: error: 'constexpr' does not name a type
 1901 |   constexpr pair<T, T> minmax(initializer_list<T> t, Compare comp);
      |   ^~~~~~~~~
p1153.cpp:1901:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1904:5: error: expected unqualified-id before 'using'
 1904 |     using minmax_result = min_max_result<T>;
      |     ^~~~~
p1153.cpp:1905:34: error: 'identity' does not name a type
 1905 |   template<class T, class Proj = identity,
      |                                  ^~~~~~~~
p1153.cpp:1906:12: error: 'indirect_strict_weak_order' has not been declared
 1906 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1906:38: error: expected '>' before '<' token
 1906 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1908:50: error: expected unqualified-id before '{' token
 1908 |       minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                  ^
p1153.cpp:1908:52: error: expected unqualified-id before ',' token
 1908 |       minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                    ^
p1153.cpp:1908:59: error: expected constructor, destructor, or type conversion before 'proj'
 1908 |       minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                           ^~~~
p1153.cpp:1908:68: error: expected unqualified-id before ')' token
 1908 |       minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                    ^
p1153.cpp:1909:12: error: 'copyable' has not been declared
 1909 |   template<copyable T, class Proj = identity,
      |            ^~~~~~~~
p1153.cpp:1909:37: error: 'identity' does not name a type
 1909 |   template<copyable T, class Proj = identity,
      |                                     ^~~~~~~~
p1153.cpp:1910:12: error: 'indirect_strict_weak_order' has not been declared
 1910 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1910:38: error: expected '>' before '<' token
 1910 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1912:49: error: expected unqualified-id before '{' token
 1912 |       minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                 ^
p1153.cpp:1912:51: error: expected unqualified-id before ',' token
 1912 |       minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                   ^
p1153.cpp:1912:58: error: expected constructor, destructor, or type conversion before 'proj'
 1912 |       minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                          ^~~~
p1153.cpp:1912:67: error: expected unqualified-id before ')' token
 1912 |       minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                   ^
p1153.cpp:1913:12: error: 'input_range' has not been declared
 1913 |   template<input_range R, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:1913:40: error: 'identity' does not name a type
 1913 |   template<input_range R, class Proj = identity,
      |                                        ^~~~~~~~
p1153.cpp:1914:12: error: 'indirect_strict_weak_order' has not been declared
 1914 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1914:38: error: expected '>' before '<' token
 1914 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1917:33: error: expected unqualified-id before '{' token
 1917 |       minmax(R&& r, Comp comp = {}, Proj proj = {});
      |                                 ^
p1153.cpp:1917:35: error: expected unqualified-id before ',' token
 1917 |       minmax(R&& r, Comp comp = {}, Proj proj = {});
      |                                   ^
p1153.cpp:1917:42: error: expected constructor, destructor, or type conversion before 'proj'
 1917 |       minmax(R&& r, Comp comp = {}, Proj proj = {});
      |                                          ^~~~
p1153.cpp:1917:51: error: expected unqualified-id before ')' token
 1917 |       minmax(R&& r, Comp comp = {}, Proj proj = {});
      |                                                   ^
p1153.cpp:1920:3: error: 'constexpr' does not name a type
 1920 |   constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
      |   ^~~~~~~~~
p1153.cpp:1920:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1922:3: error: 'constexpr' does not name a type
 1922 |   constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
      |   ^~~~~~~~~
p1153.cpp:1922:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1925:44: error: expected ',' or '...' before '&&' token
 1925 | ForwardIterator min_element(ExecutionPolicy&& exec, // see 27.3.5
      |                                            ^~
p1153.cpp:1927:114: error: expected ',' or '...' before '&&' token
 1927 | olicy, class ForwardIterator, class Compare> ForwardIterator min_element(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                         ^~

p1153.cpp:1931:12: error: 'forward_iterator' has not been declared
 1931 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:1931:32: error: 'sentinel_for' has not been declared
 1931 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                ^~~~~~~~~~~~
p1153.cpp:1931:44: error: expected '>' before '<' token
 1931 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                            ^
p1153.cpp:1933:58: error: expected unqualified-id before '{' token
 1933 |     constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                          ^
p1153.cpp:1933:60: error: expected unqualified-id before ',' token
 1933 |     constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1153.cpp:1933:67: error: expected constructor, destructor, or type conversion before 'proj'
 1933 |     constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                   ^~~~
p1153.cpp:1933:76: error: expected unqualified-id before ')' token
 1933 |     constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                            ^
p1153.cpp:1934:12: error: 'forward_range' has not been declared
 1934 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1934:42: error: 'identity' does not name a type
 1934 |   template<forward_range R, class Proj = identity,
      |                                          ^~~~~~~~
p1153.cpp:1935:12: error: 'indirect_strict_weak_order' has not been declared
 1935 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1935:38: error: expected '>' before '<' token
 1935 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1937:38: error: expected unqualified-id before '{' token
 1937 |       min_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                      ^
p1153.cpp:1937:40: error: expected unqualified-id before ',' token
 1937 |       min_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                        ^
p1153.cpp:1937:47: error: expected constructor, destructor, or type conversion before 'proj'
 1937 |       min_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                               ^~~~
p1153.cpp:1937:56: error: expected unqualified-id before ')' token
 1937 |       min_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                        ^
p1153.cpp:1940:3: error: 'constexpr' does not name a type
 1940 |   constexpr ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
      |   ^~~~~~~~~
p1153.cpp:1940:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1942:3: error: 'constexpr' does not name a type
 1942 |   constexpr ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
      |   ^~~~~~~~~
p1153.cpp:1942:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1945:44: error: expected ',' or '...' before '&&' token
 1945 | ForwardIterator max_element(ExecutionPolicy&& exec, // see 27.3.5
      |                                            ^~
p1153.cpp:1947:114: error: expected ',' or '...' before '&&' token
 1947 | olicy, class ForwardIterator, class Compare> ForwardIterator max_element(ExecutionPolicy&& exec, // see 27.3.5
      |                                                                                         ^~

p1153.cpp:1951:12: error: 'forward_iterator' has not been declared
 1951 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:1951:32: error: 'sentinel_for' has not been declared
 1951 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                ^~~~~~~~~~~~
p1153.cpp:1951:44: error: expected '>' before '<' token
 1951 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                            ^
p1153.cpp:1953:58: error: expected unqualified-id before '{' token
 1953 |     constexpr I max_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                          ^
p1153.cpp:1953:60: error: expected unqualified-id before ',' token
 1953 |     constexpr I max_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1153.cpp:1953:67: error: expected constructor, destructor, or type conversion before 'proj'
 1953 |     constexpr I max_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                   ^~~~
p1153.cpp:1953:76: error: expected unqualified-id before ')' token
 1953 |     constexpr I max_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                            ^
p1153.cpp:1954:12: error: 'forward_range' has not been declared
 1954 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1954:42: error: 'identity' does not name a type
 1954 |   template<forward_range R, class Proj = identity,
      |                                          ^~~~~~~~
p1153.cpp:1955:12: error: 'indirect_strict_weak_order' has not been declared
 1955 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1955:38: error: expected '>' before '<' token
 1955 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1957:38: error: expected unqualified-id before '{' token
 1957 |       max_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                      ^
p1153.cpp:1957:40: error: expected unqualified-id before ',' token
 1957 |       max_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                        ^
p1153.cpp:1957:47: error: expected constructor, destructor, or type conversion before 'proj'
 1957 |       max_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                               ^~~~
p1153.cpp:1957:56: error: expected unqualified-id before ')' token
 1957 |       max_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                        ^
p1153.cpp:1960:3: error: 'constexpr' does not name a type
 1960 |   constexpr pair<ForwardIterator, ForwardIterator>
      |   ^~~~~~~~~
p1153.cpp:1960:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1963:3: error: 'constexpr' does not name a type
 1963 |   constexpr pair<ForwardIterator, ForwardIterator>
      |   ^~~~~~~~~
p1153.cpp:1963:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1967:31: error: expected ',' or '...' before '&&' token
 1967 | minmax_element(ExecutionPolicy&& exec, // see 27.3.5
      |                               ^~
p1153.cpp:1971:31: error: expected ',' or '...' before '&&' token
 1971 | minmax_element(ExecutionPolicy&& exec, // see 27.3.5
      |                               ^~
p1153.cpp:1975:5: error: expected unqualified-id before 'using'
 1975 |     using minmax_element_result = min_max_result<I>;
      |     ^~~~~
p1153.cpp:1976:12: error: 'forward_iterator' has not been declared
 1976 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~
p1153.cpp:1976:32: error: 'sentinel_for' has not been declared
 1976 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                ^~~~~~~~~~~~
p1153.cpp:1976:44: error: expected '>' before '<' token
 1976 |   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
      |                                            ^
p1153.cpp:1979:51: error: expected unqualified-id before '{' token
 1979 |       minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                   ^
p1153.cpp:1979:53: error: expected unqualified-id before ',' token
 1979 |       minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                     ^
p1153.cpp:1979:60: error: expected constructor, destructor, or type conversion before 'proj'
 1979 |       minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                            ^~~~
p1153.cpp:1979:69: error: expected unqualified-id before ')' token
 1979 |       minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                     ^
p1153.cpp:1980:12: error: 'forward_range' has not been declared
 1980 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1980:42: error: 'identity' does not name a type
 1980 |   template<forward_range R, class Proj = identity,
      |                                          ^~~~~~~~
p1153.cpp:1981:12: error: 'indirect_strict_weak_order' has not been declared
 1981 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1981:38: error: expected '>' before '<' token
 1981 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1983:1: error: expected unqualified-id before '}' token
 1983 | }
      | ^
p1153.cpp:1984:15: error: expected constructor, destructor, or type conversion before '(' token
 1984 | minmax_element(R&& r, Comp comp = {}, Proj proj = {});
      |               ^
p1153.cpp:1984:37: error: expected unqualified-id before ',' token
 1984 | minmax_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                     ^
p1153.cpp:1984:44: error: expected constructor, destructor, or type conversion before 'proj'
 1984 | minmax_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                            ^~~~
p1153.cpp:1984:53: error: expected unqualified-id before ')' token
 1984 | minmax_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                     ^
p1153.cpp:1987:3: error: 'constexpr' does not name a type
 1987 |   constexpr const T& clamp(const T& v, const T& lo, const T& hi);
      |   ^~~~~~~~~
p1153.cpp:1987:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1989:3: error: 'constexpr' does not name a type
 1989 |   constexpr const T& clamp(const T& v, const T& lo, const T& hi, Compare comp);
      |   ^~~~~~~~~
p1153.cpp:1989:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:1991:34: error: 'identity' does not name a type
 1991 |   template<class T, class Proj = identity,
      |                                  ^~~~~~~~
p1153.cpp:1992:12: error: 'indirect_strict_weak_order' has not been declared
 1992 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1992:38: error: expected '>' before '<' token
 1992 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                      ^
p1153.cpp:1994:63: error: expected unqualified-id before '{' token
 1994 |       clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});
      |                                                               ^
p1153.cpp:1994:65: error: expected unqualified-id before ',' token
 1994 |       clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});
      |                                                                 ^
p1153.cpp:1994:72: error: expected constructor, destructor, or type conversion before 'proj'
 1994 |       clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});
      |                                                                        ^~~~
p1153.cpp:1994:81: error: expected unqualified-id before ')' token
 1994 |       clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});
      |                                                                                 ^
p1153.cpp:1998:3: error: 'constexpr' does not name a type
 1998 |   constexpr bool
      |   ^~~~~~~~~
p1153.cpp:1998:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:2002:3: error: 'constexpr' does not name a type
 2002 |   constexpr bool
      |   ^~~~~~~~~
p1153.cpp:2002:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:2008:40: error: expected ',' or '...' before '&&' token
 2008 | lexicographical_compare(ExecutionPolicy&& exec, // see 27.3.5
      |                                        ^~
p1153.cpp:2014:40: error: expected ',' or '...' before '&&' token
 2014 | lexicographical_compare(ExecutionPolicy&& exec, // see 27.3.5
      |                                        ^~
p1153.cpp:2019:12: error: 'input_iterator' has not been declared
 2019 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |            ^~~~~~~~~~~~~~
p1153.cpp:2019:31: error: 'sentinel_for' has not been declared
 2019 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                               ^~~~~~~~~~~~
p1153.cpp:2019:43: error: expected '>' before '<' token
 2019 |   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
      |                                           ^
p1153.cpp:2025:43: error: expected unqualified-id before '{' token
 2025 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                           ^
p1153.cpp:2025:45: error: expected unqualified-id before ',' token
 2025 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                             ^
p1153.cpp:2025:53: error: expected constructor, destructor, or type conversion before 'proj1'
 2025 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                     ^~~~~
p1153.cpp:2025:63: error: expected unqualified-id before ',' token
 2025 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                               ^
p1153.cpp:2025:71: error: expected constructor, destructor, or type conversion before 'proj2'
 2025 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                       ^~~~~
p1153.cpp:2025:81: error: expected unqualified-id before ')' token
 2025 |                               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                                 ^
p1153.cpp:2026:12: error: 'input_range' has not been declared
 2026 |   template<input_range R1, input_range R2, class Proj1 = identity,
      |            ^~~~~~~~~~~
p1153.cpp:2026:28: error: 'input_range' has not been declared
 2026 |   template<input_range R1, input_range R2, class Proj1 = identity,
      |                            ^~~~~~~~~~~
p1153.cpp:2026:58: error: 'identity' does not name a type
 2026 |   template<input_range R1, input_range R2, class Proj1 = identity,
      |                                                          ^~~~~~~~
p1153.cpp:2027:26: error: 'identity' does not name a type
 2027 |            class Proj2 = identity,
      |                          ^~~~~~~~
p1153.cpp:2028:12: error: 'indirect_strict_weak_order' has not been declared
 2028 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:2028:38: error: expected '>' before '<' token
 2028 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                      ^
p1153.cpp:2031:61: error: expected unqualified-id before '{' token
 2031 |       lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
      |                                                             ^
p1153.cpp:2031:63: error: expected unqualified-id before ',' token
 2031 |       lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
      |                                                               ^
p1153.cpp:2032:37: error: expected constructor, destructor, or type conversion before 'proj1'
 2032 |                               Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                     ^~~~~
p1153.cpp:2032:47: error: expected unqualified-id before ',' token
 2032 |                               Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                               ^
p1153.cpp:2032:55: error: expected constructor, destructor, or type conversion before 'proj2'
 2032 |                               Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                       ^~~~~
p1153.cpp:2032:65: error: expected unqualified-id before ')' token
 2032 |                               Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                 ^
p1153.cpp:2036:3: error: 'constexpr' does not name a type
 2036 |   constexpr auto
      |   ^~~~~~~~~
p1153.cpp:2036:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:2039:1: error: 'InputIterator2' does not name a type
 2039 | InputIterator2 b2, InputIterator2 e2,
      | ^~~~~~~~~~~~~~
p1153.cpp:2041:3: error: expected declaration before '}' token
 2041 | } }
      |   ^
p1153.cpp:2042:1: error: 'Algorithm' does not name a type
 2042 | Algorithm result types
      | ^~~~~~~~~
p1153.cpp:2050:3: error: 'constexpr' does not name a type
 2050 |   constexpr bool next_permutation(BidirectionalIterator first,
      |   ^~~~~~~~~
p1153.cpp:2050:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:2053:3: error: 'constexpr' does not name a type
 2053 |   constexpr bool next_permutation(BidirectionalIterator first,
      |   ^~~~~~~~~
p1153.cpp:2053:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:2057:5: error: expected unqualified-id before 'using'
 2057 |     using next_permutation_result = in_found_result<I>;
      |     ^~~~~
p1153.cpp:2058:12: error: 'bidirectional_iterator' has not been declared
 2058 |   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:2058:38: error: 'sentinel_for' has not been declared
 2058 |   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                      ^~~~~~~~~~~~
p1153.cpp:2058:50: error: expected '>' before '<' token
 2058 |   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                  ^
p1153.cpp:2060:5: error: 'requires' does not name a type
 2060 |     requires sortable<I, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:2060:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:2062:55: error: expected unqualified-id before ',' token
 2062 |       next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                       ^
p1153.cpp:2062:62: error: expected constructor, destructor, or type conversion before 'proj'
 2062 |       next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                              ^~~~
p1153.cpp:2062:71: error: expected unqualified-id before ')' token
 2062 |       next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                       ^
p1153.cpp:2063:12: error: 'bidirectional_range' has not been declared
 2063 |   template<bidirectional_range R, class Comp = ranges::less,
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:2063:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 2063 |   template<bidirectional_range R, class Comp = ranges::less,
      |                                                        ^~~~
p1153.cpp:2064:25: error: 'identity' does not name a type
 2064 |            class Proj = identity>
      |                         ^~~~~~~~
p1153.cpp:2065:5: error: 'requires' does not name a type
 2065 |     requires sortable<iterator_t<R>, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:2065:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:2067:45: error: expected unqualified-id before ',' token
 2067 |       next_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                             ^
p1153.cpp:2067:52: error: expected constructor, destructor, or type conversion before 'proj'
 2067 |       next_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                                    ^~~~
p1153.cpp:2067:61: error: expected unqualified-id before ')' token
 2067 |       next_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                                             ^
p1153.cpp:2070:3: error: 'constexpr' does not name a type
 2070 |   constexpr bool prev_permutation(BidirectionalIterator first,
      |   ^~~~~~~~~
p1153.cpp:2070:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:2073:3: error: 'constexpr' does not name a type
 2073 |   constexpr bool prev_permutation(BidirectionalIterator first,
      |   ^~~~~~~~~
p1153.cpp:2073:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p1153.cpp:2077:5: error: expected unqualified-id before 'using'
 2077 |     using prev_permutation_result = in_found_result<I>;
      |     ^~~~~
p1153.cpp:2078:12: error: 'bidirectional_iterator' has not been declared
 2078 |   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |            ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:2078:38: error: 'sentinel_for' has not been declared
 2078 |   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                      ^~~~~~~~~~~~
p1153.cpp:2078:50: error: expected '>' before '<' token
 2078 |   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                  ^
p1153.cpp:2080:5: error: 'requires' does not name a type
 2080 |     requires sortable<I, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:2080:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:2082:55: error: expected unqualified-id before ',' token
 2082 |       prev_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                       ^
p1153.cpp:2082:62: error: expected constructor, destructor, or type conversion before 'proj'
 2082 |       prev_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                              ^~~~
p1153.cpp:2082:71: error: expected unqualified-id before ')' token
 2082 |       prev_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                       ^
p1153.cpp:2083:12: error: 'bidirectional_range' has not been declared
 2083 |   template<bidirectional_range R, class Comp = ranges::less,
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:2083:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 2083 |   template<bidirectional_range R, class Comp = ranges::less,
      |                                                        ^~~~
p1153.cpp:2084:25: error: 'identity' does not name a type
 2084 |            class Proj = identity>
      |                         ^~~~~~~~
p1153.cpp:2085:5: error: 'requires' does not name a type
 2085 |     requires sortable<iterator_t<R>, Comp, Proj>
      |     ^~~~~~~~
p1153.cpp:2085:5: note: 'requires' only available with '-std=c++20' or '-fconcepts'
p1153.cpp:2087:40: error: expected unqualified-id before ',' token
 2087 |  prev_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                        ^
p1153.cpp:2087:47: error: expected constructor, destructor, or type conversion before 'proj'
 2087 |  prev_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                               ^~~~
p1153.cpp:2087:56: error: expected unqualified-id before ')' token
 2087 |  prev_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                                        ^

$ g++ p1153.cpp -std=2b -o p1153g -I. -Wall
p1153.cpp:150:1: error: expected unqualified-id before '}' token
  150 | }
      | ^
p1153.cpp:151:12: error: expected constructor, destructor, or type conversion before '(' token
  151 | find_if_not(R&& r, Pred pred, Proj proj = {});
      |            ^
p1153.cpp:151:45: error: expected unqualified-id before ')' token
  151 | find_if_not(R&& r, Pred pred, Proj proj = {});
      |                                             ^
p1153.cpp:179:15: error: 'subrange' does not name a type
  179 |     constexpr subrange<I1>
      |               ^~~~~~~~
p1153.cpp:180:72: error: expected unqualified-id before ',' token
  180 |       find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
      |                                                                        ^
p1153.cpp:181:22: error: expected constructor, destructor, or type conversion before 'proj1'
  181 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                      ^~~~~
p1153.cpp:181:32: error: expected unqualified-id before ',' token
  181 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                ^
p1153.cpp:181:40: error: expected constructor, destructor, or type conversion before 'proj2'
  181 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                        ^~~~~
p1153.cpp:181:50: error: expected unqualified-id before ')' token
  181 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                  ^
p1153.cpp:185:15: error: 'borrowed_subrange_t' does not name a type; did you mean 'borrowed_iterator_t'?
  185 |     constexpr borrowed_subrange_t<R1>
      |               ^~~~~~~~~~~~~~~~~~~
      |               borrowed_iterator_t
p1153.cpp:186:48: error: expected unqualified-id before ',' token
  186 |       find_end(R1&& r1, R2&& r2, Pred pred = {},
      |                                                ^
p1153.cpp:187:22: error: expected constructor, destructor, or type conversion before 'proj1'
  187 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                      ^~~~~
p1153.cpp:187:32: error: expected unqualified-id before ',' token
  187 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                ^
p1153.cpp:187:40: error: expected constructor, destructor, or type conversion before 'proj2'
  187 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                        ^~~~~
p1153.cpp:187:50: error: expected unqualified-id before ')' token
  187 |                Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                  ^
p1153.cpp:248:12: error: parse error in template argument list
  248 |            indirect_binary_predicate<projected<iterator_t<R>, Proj>,
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  249 | // 27.6.9, count
      | ~~~~~~~~~~~~~~~~
  250 | template<class InputIterator, class T>
      | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  251 |   constexpr typename iterator_traits<InputIterator>::difference_type
      |   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  252 |     count(InputIterator first, InputIterator last, const T& value);
      |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:248:12: error: template argument 3 is invalid
p1153.cpp:252:67: error: expected '>' before ';' token
  252 |     count(InputIterator first, InputIterator last, const T& value);
      |                                                                   ^
p1153.cpp:252:67: error: expected unqualified-id before ';' token
p1153.cpp:263:53: error: 'R' was not declared in this scope
  263 |                                projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
      |                                                     ^
p1153.cpp:263:54: error: template argument 1 is invalid
  263 |                                projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
      |                                                      ^
p1153.cpp:263:57: error: 'Proj' was not declared in this scope; did you mean 'proj'?
  263 |                                projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
      |                                                         ^~~~
      |                                                         proj
p1153.cpp:263:57: error: template argument 1 is invalid
p1153.cpp:263:57: error: template argument 2 is invalid
p1153.cpp:263:61: error: expected unqualified-id before '>' token
  263 |                                projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
      |                                                             ^~
p1153.cpp:264:36: error: expected unqualified-id before ',' token
  264 | adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
      |                                    ^
p1153.cpp:264:43: error: expected constructor, destructor, or type conversion before 'proj'
  264 | adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
      |                                           ^~~~
p1153.cpp:264:52: error: expected unqualified-id before ')' token
  264 | adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
      |                                                    ^
p1153.cpp:265:35: error: 'R' was not declared in this scope
  265 |     constexpr borrowed_iterator_t<R>
      |                                   ^
p1153.cpp:265:36: error: template argument 1 is invalid
  265 |     constexpr borrowed_iterator_t<R>
      |                                    ^
p1153.cpp:266:1: error: expected unqualified-id before '}' token
  266 | }
      | ^
p1153.cpp:379:60: error: 'template<class I1, class S1, class I2, class S2, class Pred, class Proj1, class Proj2>  requires (input_iterator<I1>) && (sentinel_for<S1, I1>) && (input_iterator<I2>) && (sentinel_for<S2, I2>) && (indirectly_comparable<I1, I2, Pred, Proj1, Proj2>) constexpr bool std::ranges::equal(I1, S1, I2, S2, Pred, Proj1, Proj2)' redeclared as different kind of entity
  379 |                          Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                            ^
In file included from /usr/local/include/c++/12.1.0/bits/ranges_uninitialized.h:36,
                 from /usr/local/include/c++/12.1.0/memory:86,
                 from N4910.h:14,
                 from p1153.cpp:10:
/usr/local/include/c++/12.1.0/bits/ranges_algobase.h:159:31: note: previous declaration 'constexpr const std::ranges::__equal_fn std::ranges::equal'
  159 |   inline constexpr __equal_fn equal{};
      |                               ^~~~~
p1153.cpp:384:35: error: 'template<class R1, class R2, class Pred, class Proj1, class Proj2>  requires (input_range<R1>) && (input_range<R2>) && (indirectly_comparable<decltype(std::ranges::__cust_access::__begin((declval<_Container&>)())), decltype(std::ranges::__cust_access::__begin((declval<_Range2&>)())), Pred, Proj1, Proj2>) constexpr bool std::ranges::equal(R1&&, R2&&, Pred, Proj1, Proj2)' redeclared as different kind of entity
  384 | Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                   ^
/usr/local/include/c++/12.1.0/bits/ranges_algobase.h:159:31: note: previous declaration 'constexpr const std::ranges::__equal_fn std::ranges::equal'
  159 |   inline constexpr __equal_fn equal{};
      |                               ^~~~~
p1153.cpp:444:15: error: 'subrange' does not name a type
  444 |     constexpr subrange<I1>
      |               ^~~~~~~~
p1153.cpp:445:64: error: expected unqualified-id before ',' token
  445 | search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
      |                                                                ^
p1153.cpp:446:20: error: expected constructor, destructor, or type conversion before 'proj1'
  446 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                    ^~~~~
p1153.cpp:446:30: error: expected unqualified-id before ',' token
  446 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                              ^
p1153.cpp:446:38: error: expected constructor, destructor, or type conversion before 'proj2'
  446 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                      ^~~~~
p1153.cpp:446:48: error: expected unqualified-id before ')' token
  446 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                ^
p1153.cpp:450:15: error: 'borrowed_subrange_t' does not name a type; did you mean 'borrowed_iterator_t'?
  450 |     constexpr borrowed_subrange_t<R1>
      |               ^~~~~~~~~~~~~~~~~~~
      |               borrowed_iterator_t
p1153.cpp:451:46: error: expected unqualified-id before ',' token
  451 |       search(R1&& r1, R2&& r2, Pred pred = {},
      |                                              ^
p1153.cpp:452:20: error: expected constructor, destructor, or type conversion before 'proj1'
  452 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                    ^~~~~
p1153.cpp:452:30: error: expected unqualified-id before ',' token
  452 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                              ^
p1153.cpp:452:38: error: expected constructor, destructor, or type conversion before 'proj2'
  452 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                      ^~~~~
p1153.cpp:452:48: error: expected unqualified-id before ')' token
  452 |              Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                ^
p1153.cpp:479:15: error: 'subrange' does not name a type
  479 |     constexpr subrange<I>
      |               ^~~~~~~~
p1153.cpp:481:46: error: expected unqualified-id before ',' token
  481 |                const T& value, Pred pred = {}, Proj proj = {});
      |                                              ^
p1153.cpp:481:53: error: expected constructor, destructor, or type conversion before 'proj'
  481 |                const T& value, Pred pred = {}, Proj proj = {});
      |                                                     ^~~~
p1153.cpp:481:62: error: expected unqualified-id before ')' token
  481 |                const T& value, Pred pred = {}, Proj proj = {});
      |                                                              ^
p1153.cpp:485:15: error: 'borrowed_subrange_t' does not name a type; did you mean 'borrowed_iterator_t'?
  485 |     constexpr borrowed_subrange_t<R>
      |               ^~~~~~~~~~~~~~~~~~~
      |               borrowed_iterator_t
p1153.cpp:487:46: error: expected unqualified-id before ',' token
  487 |                const T& value, Pred pred = {}, Proj proj = {});
      |                                              ^
p1153.cpp:487:53: error: expected constructor, destructor, or type conversion before 'proj'
  487 |                const T& value, Pred pred = {}, Proj proj = {});
      |                                                     ^~~~
p1153.cpp:487:62: error: expected unqualified-id before ')' token
  487 |                const T& value, Pred pred = {}, Proj proj = {});
      |                                                              ^
p1153.cpp:534:37: error: 'template<class I, class S, class O>  requires (input_iterator<I>) && (sentinel_for<S, I>) && (weakly_incrementable<O>) && (indirectly_copyable<I, O>) constexpr std::ranges::copy_result<_Iter, _Out> std::ranges::copy(I, S, O)' redeclared as different kind of entity
  534 |       copy(I first, S last, O result);
      |                                     ^
/usr/local/include/c++/12.1.0/bits/ranges_algobase.h:319:30: note: previous declaration 'constexpr const std::ranges::__copy_fn std::ranges::copy'
  319 |   inline constexpr __copy_fn copy{};
      |                              ^~~~
p1153.cpp:538:27: error: 'template<class R, class O>  requires (input_range<R>) && (weakly_incrementable<O>) && (indirectly_copyable<decltype(std::ranges::__cust_access::__begin((declval<_Container&>)())), O>) constexpr std::ranges::copy_result<std::ranges::borrowed_iterator_t<_Range>, _Out> std::ranges::copy(R&&, O)' redeclared as different kind of entity
  538 |       copy(R&& r, O result);
      |                           ^
/usr/local/include/c++/12.1.0/bits/ranges_algobase.h:319:30: note: previous declaration 'constexpr const std::ranges::__copy_fn std::ranges::copy'
  319 |   inline constexpr __copy_fn copy{};
      |                              ^~~~
p1153.cpp:554:55: error: 'template<class I, class O>  requires (input_iterator<I>) && (weakly_incrementable<O>) && (indirectly_copyable<I, O>) constexpr std::ranges::copy_n_result<_Iter, _Out> std::ranges::copy_n(I, std::iter_difference_t<_Iter>, O)' redeclared as different kind of entity
  554 |       copy_n(I first, iter_difference_t<I> n, O result);
      |                                                       ^
/usr/local/include/c++/12.1.0/bits/ranges_algobase.h:512:32: note: previous declaration 'constexpr const std::ranges::__copy_n_fn std::ranges::copy_n'
  512 |   inline constexpr __copy_n_fn copy_n{};
      |                                ^~~~~~
p1153.cpp:589:49: error: 'template<class I1, class S1, class I2>  requires (bidirectional_iterator<I1>) && (sentinel_for<S1, I1>) && (bidirectional_iterator<I2>) && (indirectly_copyable<I1, I2>) constexpr std::ranges::copy_backward_result<_Iter1, _Iter2> std::ranges::copy_backward(I1, S1, I2)' redeclared as different kind of entity
  589 |       copy_backward(I1 first, S1 last, I2 result);
      |                                                 ^
/usr/local/include/c++/12.1.0/bits/ranges_algobase.h:460:39: note: previous declaration 'constexpr const std::ranges::__copy_backward_fn std::ranges::copy_backward'
  460 |   inline constexpr __copy_backward_fn copy_backward{};
      |                                       ^~~~~~~~~~~~~
p1153.cpp:593:36: error: 'template<class R, class I>  requires (bidirectional_range<R>) && (bidirectional_iterator<I>) && (indirectly_copyable<decltype(std::ranges::__cust_access::__begin((declval<_Container&>)())), I>) constexpr std::ranges::copy_backward_result<std::ranges::borrowed_iterator_t<_Range>, _Iter> std::ranges::copy_backward(R&&, I)' redeclared as different kind of entity
  593 |       copy_backward(R&& r, I result);
      |                                    ^
/usr/local/include/c++/12.1.0/bits/ranges_algobase.h:460:39: note: previous declaration 'constexpr const std::ranges::__copy_backward_fn std::ranges::copy_backward'
  460 |   inline constexpr __copy_backward_fn copy_backward{};
      |                                       ^~~~~~~~~~~~~
p1153.cpp:610:37: error: 'template<class I, class S, class O>  requires (input_iterator<I>) && (sentinel_for<S, I>) && (weakly_incrementable<O>) && (indirectly_movable<I, O>) constexpr std::ranges::move_result<_Iter, _Out> std::ranges::move(I, S, O)' redeclared as different kind of entity
  610 |       move(I first, S last, O result);
      |                                     ^
/usr/local/include/c++/12.1.0/bits/ranges_algobase.h:344:30: note: previous declaration 'constexpr const std::ranges::__move_fn std::ranges::move'
  344 |   inline constexpr __move_fn move{};
      |                              ^~~~
p1153.cpp:614:27: error: 'template<class R, class O>  requires (input_range<R>) && (weakly_incrementable<O>) && (indirectly_movable<decltype(std::ranges::__cust_access::__begin((declval<_Container&>)())), O>) constexpr std::ranges::move_result<std::ranges::borrowed_iterator_t<_Range>, _Out> std::ranges::move(R&&, O)' redeclared as different kind of entity
  614 |       move(R&& r, O result);
      |                           ^
/usr/local/include/c++/12.1.0/bits/ranges_algobase.h:344:30: note: previous declaration 'constexpr const std::ranges::__move_fn std::ranges::move'
  344 |   inline constexpr __move_fn move{};
      |                              ^~~~
p1153.cpp:626:49: error: 'template<class I1, class S1, class I2>  requires (bidirectional_iterator<I1>) && (sentinel_for<S1, I1>) && (bidirectional_iterator<I2>) && (indirectly_movable<I1, I2>) constexpr std::ranges::move_backward_result<_Iter1, _Iter2> std::ranges::move_backward(I1, S1, I2)' redeclared as different kind of entity
  626 |       move_backward(I1 first, S1 last, I2 result);
      |                                                 ^
/usr/local/include/c++/12.1.0/bits/ranges_algobase.h:485:39: note: previous declaration 'constexpr const std::ranges::__move_backward_fn std::ranges::move_backward'
  485 |   inline constexpr __move_backward_fn move_backward{};
      |                                       ^~~~~~~~~~~~~
p1153.cpp:630:36: error: 'template<class R, class I>  requires (bidirectional_range<R>) && (bidirectional_iterator<I>) && (indirectly_movable<decltype(std::ranges::__cust_access::__begin((declval<_Container&>)())), I>) constexpr std::ranges::move_backward_result<std::ranges::borrowed_iterator_t<_Range>, _Iter> std::ranges::move_backward(R&&, I)' redeclared as different kind of entity
  630 |       move_backward(R&& r, I result);
      |                                    ^
/usr/local/include/c++/12.1.0/bits/ranges_algobase.h:485:39: note: previous declaration 'constexpr const std::ranges::__move_backward_fn std::ranges::move_backward'
  485 |   inline constexpr __move_backward_fn move_backward{};
      |                                       ^~~~~~~~~~~~~
p1153.cpp:760:1: error: expected identifier before 'namespace'
  760 | namespace ranges {
      | ^~~~~~~~~
p1153.cpp:760:1: error: expected ',' or '...' before 'namespace'
p1153.cpp:798:83: error: expected ')' before ';' token
  798 |   constexpr void fill(ForwardIterator first, ForwardIterator last, const T& value);
      |                                                                                   ^
      |                                                                                   )
p1153.cpp:759:33: note: to match this '('
  759 | ForwardIterator2 replace_copy_if(ExecutionPolicy&& exec, // see 27.3.5
      |                                 ^
p1153.cpp:810:53: error: 'template<class T, class O, class S>  requires (output_iterator<O, const T&>) && (sentinel_for<S, O>) constexpr O std::ranges::fill(O, S, const T&)' redeclared as different kind of entity
  810 |     constexpr O fill(O first, S last, const T& value);
      |                                                     ^
/usr/local/include/c++/12.1.0/bits/ranges_algobase.h:596:30: note: previous declaration 'constexpr const std::ranges::__fill_fn std::ranges::fill'
  596 |   inline constexpr __fill_fn fill{};
      |                              ^~~~
p1153.cpp:812:64: error: 'template<class T, class R>  requires  output_range<R, const T&> constexpr std::ranges::borrowed_iterator_t<_Range> std::ranges::fill(R&&, const T&)' redeclared as different kind of entity
  812 |     constexpr borrowed_iterator_t<R> fill(R&& r, const T& value);
      |                                                                ^
/usr/local/include/c++/12.1.0/bits/ranges_algobase.h:596:30: note: previous declaration 'constexpr const std::ranges::__fill_fn std::ranges::fill'
  596 |   inline constexpr __fill_fn fill{};
      |                              ^~~~
p1153.cpp:814:71: error: 'template<class T, class O>  requires  output_iterator<O, const T&> constexpr O std::ranges::fill_n(O, std::iter_difference_t<_Iter>, const T&)' redeclared as different kind of entity
  814 |     constexpr O fill_n(O first, iter_difference_t<O> n, const T& value);
      |                                                                       ^
/usr/local/include/c++/12.1.0/bits/ranges_algobase.h:557:32: note: previous declaration 'constexpr const std::ranges::__fill_n_fn std::ranges::fill_n'
  557 |   inline constexpr __fill_n_fn fill_n{};
      |                                ^~~~~~
p1153.cpp:855:15: error: 'subrange' does not name a type
  855 |     constexpr subrange<I> remove(I first, S last, const T& value, Proj proj = {});
      |               ^~~~~~~~
p1153.cpp:855:81: error: expected unqualified-id before ')' token
  855 |     constexpr subrange<I> remove(I first, S last, const T& value, Proj proj = {});
      |                                                                                 ^
p1153.cpp:860:15: error: 'borrowed_subrange_t' does not name a type; did you mean 'borrowed_iterator_t'?
  860 |     constexpr borrowed_subrange_t<R>
      |               ^~~~~~~~~~~~~~~~~~~
      |               borrowed_iterator_t
p1153.cpp:861:51: error: expected unqualified-id before ')' token
  861 |       remove(R&& r, const T& value, Proj proj = {});
      |                                                   ^
p1153.cpp:864:15: error: 'subrange' does not name a type
  864 |     constexpr subrange<I> remove_if(I first, S last, Pred pred, Proj proj = {});
      |               ^~~~~~~~
p1153.cpp:864:79: error: expected unqualified-id before ')' token
  864 |     constexpr subrange<I> remove_if(I first, S last, Pred pred, Proj proj = {});
      |                                                                               ^
p1153.cpp:868:15: error: 'borrowed_subrange_t' does not name a type; did you mean 'borrowed_iterator_t'?
  868 |     constexpr borrowed_subrange_t<R>
      |               ^~~~~~~~~~~~~~~~~~~
      |               borrowed_iterator_t
p1153.cpp:869:49: error: expected unqualified-id before ')' token
  869 |       remove_if(R&& r, Pred pred, Proj proj = {});
      |                                                 ^
p1153.cpp:935:15: error: 'subrange' does not name a type
  935 |     constexpr subrange<I> unique(I first, S last, C comp = {}, Proj proj = {});
      |               ^~~~~~~~
p1153.cpp:935:62: error: expected unqualified-id before ',' token
  935 |     constexpr subrange<I> unique(I first, S last, C comp = {}, Proj proj = {});
      |                                                              ^
p1153.cpp:935:69: error: expected constructor, destructor, or type conversion before 'proj'
  935 |     constexpr subrange<I> unique(I first, S last, C comp = {}, Proj proj = {});
      |                                                                     ^~~~
p1153.cpp:935:78: error: expected unqualified-id before ')' token
  935 |     constexpr subrange<I> unique(I first, S last, C comp = {}, Proj proj = {});
      |                                                                              ^
p1153.cpp:939:15: error: 'borrowed_subrange_t' does not name a type; did you mean 'borrowed_iterator_t'?
  939 |     constexpr borrowed_subrange_t<R>
      |               ^~~~~~~~~~~~~~~~~~~
      |               borrowed_iterator_t
p1153.cpp:940:32: error: expected unqualified-id before ',' token
  940 |       unique(R&& r, C comp = {}, Proj proj = {});
      |                                ^
p1153.cpp:940:39: error: expected constructor, destructor, or type conversion before 'proj'
  940 |       unique(R&& r, C comp = {}, Proj proj = {});
      |                                       ^~~~
p1153.cpp:940:48: error: expected unqualified-id before ')' token
  940 |       unique(R&& r, C comp = {}, Proj proj = {});
      |                                                ^
p1153.cpp:1027:15: error: 'subrange' does not name a type
 1027 |     constexpr subrange<I> rotate(I first, I middle, S last);
      |               ^~~~~~~~
p1153.cpp:1031:15: error: 'borrowed_subrange_t' does not name a type; did you mean 'borrowed_iterator_t'?
 1031 |     constexpr borrowed_subrange_t<R> rotate(R&& r, iterator_t<R> middle);
      |               ^~~~~~~~~~~~~~~~~~~
      |               borrowed_iterator_t
p1153.cpp:1064:14: error: 'uniform_random_bit_generator' was not declared in this scope
 1064 |              uniform_random_bit_generator<remove_reference_t<Gen>>
      |              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1063:40: error: expression must be enclosed in parentheses
 1063 |              indirectly_copyable<I, O> &&
      |                                        ^~
p1153.cpp:1064:14: error: 'uniform_random_bit_generator' does not name a type
 1064 |              uniform_random_bit_generator<remove_reference_t<Gen>>
      |              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1069:14: error: 'uniform_random_bit_generator' was not declared in this scope
 1069 |              uniform_random_bit_generator<remove_reference_t<Gen>>
      |              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1068:52: error: expression must be enclosed in parentheses
 1068 |              indirectly_copyable<iterator_t<R>, O> &&
      |                                                    ^~
p1153.cpp:1069:14: error: 'uniform_random_bit_generator' does not name a type
 1069 |              uniform_random_bit_generator<remove_reference_t<Gen>>
      |              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1080:14: error: 'uniform_random_bit_generator' was not declared in this scope
 1080 |              uniform_random_bit_generator<remove_reference_t<Gen>>
      |              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1079:28: error: expression must be enclosed in parentheses
 1079 |     requires permutable<I> &&
      |                            ^~
p1153.cpp:1080:14: error: 'uniform_random_bit_generator' does not name a type
 1080 |              uniform_random_bit_generator<remove_reference_t<Gen>>
      |              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1084:14: error: 'uniform_random_bit_generator' was not declared in this scope
 1084 |              uniform_random_bit_generator<remove_reference_t<Gen>>
      |              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1083:40: error: expression must be enclosed in parentheses
 1083 |     requires permutable<iterator_t<R>> &&
      |                                        ^~
p1153.cpp:1084:14: error: 'uniform_random_bit_generator' does not name a type
 1084 |              uniform_random_bit_generator<remove_reference_t<Gen>>
      |              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1099:15: error: 'subrange' does not name a type
 1099 |     constexpr subrange<I> shift_left(I first, S last, iter_difference_t<I> n);
      |               ^~~~~~~~
p1153.cpp:1102:15: error: 'borrowed_subrange_t' does not name a type; did you mean 'borrowed_iterator_t'?
 1102 |     constexpr borrowed_subrange_t<R> shift_left(R&& r, range_difference_t<R> n);
      |               ^~~~~~~~~~~~~~~~~~~
      |               borrowed_iterator_t
p1153.cpp:1115:15: error: 'subrange' does not name a type
 1115 |     constexpr subrange<I> shift_right(I first, S last, iter_difference_t<I> n);
      |               ^~~~~~~~
p1153.cpp:1118:15: error: 'borrowed_subrange_t' does not name a type; did you mean 'borrowed_iterator_t'?
 1118 |     constexpr borrowed_subrange_t<R> shift_right(R&& r, range_difference_t<R> n);
      |               ^~~~~~~~~~~~~~~~~~~
      |               borrowed_iterator_t
p1153.cpp:1178:1: error: expected identifier before '}' token
 1178 | }
      | ^
p1153.cpp:1178:1: error: expected ',' or '...' before '}' token
p1153.cpp:1177:73: error: expected ')' before '}' token
 1177 |                 RandomAccessIterator first, RandomAccessIterator middle,
      |                                                                         ^
      |                                                                         )
 1178 | }
      | ~                                                                        
p1153.cpp:1176:18: note: to match this '('
 1176 | void partial_sort(ExecutionPolicy&& exec, // see 27.3.5
      |                  ^
p1153.cpp:1178:1: error: expected initializer before '}' token
 1178 | }
      | ^
p1153.cpp:1179:1: error: 'RandomAccessIterator' does not name a type
 1179 | RandomAccessIterator last, Compare comp);
      | ^~~~~~~~~~~~~~~~~~~~
p1153.cpp:1181:70: error: reference to 'ranges' is ambiguous
 1181 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                                      ^~~~~~
In file included from /usr/local/include/c++/12.1.0/compare:39,
                 from /usr/local/include/c++/12.1.0/bits/char_traits.h:45,
                 from /usr/local/include/c++/12.1.0/ios:40,
                 from /usr/local/include/c++/12.1.0/ostream:38,
                 from /usr/local/include/c++/12.1.0/iostream:39,
                 from N4910.h:2:
/usr/local/include/c++/12.1.0/concepts:163:13: note: candidates are: 'namespace std::ranges { }'
  163 |   namespace ranges
      |             ^~~~~~
p1153.cpp:1180:11: note:                 'namespace ranges { }'
 1180 | namespace ranges {
      |           ^~~~~~
p1153.cpp:1181:76: error: expected '>' before '::' token
 1181 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                                            ^~
p1153.cpp:1183:32: error: 'Proj' was not declared in this scope
 1183 |     requires sortable<I, Comp, Proj>
      |                                ^~~~
p1153.cpp:1183:14: error: template argument 3 is invalid
 1183 |     requires sortable<I, Comp, Proj>
      |              ^~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1185:63: error: 'Proj' has not been declared
 1185 |       partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});
      |                                                               ^~~~
p1153.cpp:1186:12: error: 'random_access_range' has not been declared
 1186 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1186:48: error: reference to 'ranges' is ambiguous
 1186 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                ^~~~~~
/usr/local/include/c++/12.1.0/concepts:163:13: note: candidates are: 'namespace std::ranges { }'
  163 |   namespace ranges
      |             ^~~~~~
p1153.cpp:1180:11: note:                 'namespace ranges { }'
 1180 | namespace ranges {
      |           ^~~~~~
p1153.cpp:1186:54: error: expected '>' before '::' token
 1186 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                      ^~
p1153.cpp:1187:34: error: 'R' was not declared in this scope
 1187 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:1187:34: error: 'R' was not declared in this scope
p1153.cpp:1187:34: error: 'R' was not declared in this scope
p1153.cpp:1187:34: error: 'R' was not declared in this scope
p1153.cpp:1187:34: error: 'R' was not declared in this scope
p1153.cpp:1187:34: error: 'R' was not declared in this scope
p1153.cpp:1187:34: error: 'R' was not declared in this scope
p1153.cpp:1187:34: error: 'R' was not declared in this scope
p1153.cpp:1187:34: error: 'R' was not declared in this scope
p1153.cpp:1187:34: error: 'R' was not declared in this scope
p1153.cpp:1187:34: error: 'R' was not declared in this scope
p1153.cpp:1187:23: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1187 |     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:
/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>;
      |           ^~~~~~~~~~
p1153.cpp:1187:34: error: 'R' was not declared in this scope
 1187 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:1187:14: error: template argument 1 is invalid
 1187 |     requires sortable<iterator_t<R>, Comp, Proj>
      |              ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1187:36: error: expected unqualified-id before ',' token
 1187 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                    ^
p1153.cpp:1189:63: error: expected unqualified-id before ',' token
 1189 |       partial_sort(R&& r, iterator_t<R> middle, Comp comp = {},
      |                                                               ^
p1153.cpp:1190:25: error: expected constructor, destructor, or type conversion before 'proj'
 1190 |                    Proj proj = {});
      |                         ^~~~
p1153.cpp:1190:34: error: expected unqualified-id before ')' token
 1190 |                    Proj proj = {});
      |                                  ^
p1153.cpp:1219:38: error: 'in_out_result' does not name a type
 1219 |     using partial_sort_copy_result = in_out_result<I, O>;
      |                                      ^~~~~~~~~~~~~
p1153.cpp:1222:25: error: reference to 'ranges' is ambiguous
 1222 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                         ^~~~~~
/usr/local/include/c++/12.1.0/concepts:163:13: note: candidates are: 'namespace std::ranges { }'
  163 |   namespace ranges
      |             ^~~~~~
p1153.cpp:1180:11: note:                 'namespace ranges { }'
 1180 | namespace ranges {
      |           ^~~~~~
p1153.cpp:1222:31: error: expected '>' before '::' token
 1222 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                               ^~
p1153.cpp:1223:64: error: 'Proj2' was not declared in this scope
 1223 |     requires indirectly_copyable<I1, I2> && sortable<I2, Comp, Proj2> &&
      |                                                                ^~~~~
p1153.cpp:1223:45: error: template argument 3 is invalid
 1223 |     requires indirectly_copyable<I1, I2> && sortable<I2, Comp, Proj2> &&
      |                                             ^~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1224:61: error: 'Proj1' was not declared in this scope
 1224 |              indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
      |                                                             ^~~~~
p1153.cpp:1224:66: error: template argument 2 is invalid
 1224 |              indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
      |                                                                  ^
p1153.cpp:1224:83: error: 'Proj2' was not declared in this scope
 1224 |              indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
      |                                                                                   ^~~~~
p1153.cpp:1224:83: error: template argument 2 is invalid
p1153.cpp:1224:14: error: template argument 2 is invalid
 1224 |              indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
      |              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1224:14: error: template argument 3 is invalid
p1153.cpp:1225:15: error: 'partial_sort_copy_result' does not name a type
 1225 |     constexpr partial_sort_copy_result<I1, I2>
      |               ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1227:39: error: expected unqualified-id before ',' token
 1227 |                         Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                       ^
p1153.cpp:1227:47: error: expected constructor, destructor, or type conversion before 'proj1'
 1227 |                         Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                               ^~~~~
p1153.cpp:1227:57: error: expected unqualified-id before ',' token
 1227 |                         Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                         ^
p1153.cpp:1227:65: error: expected constructor, destructor, or type conversion before 'proj2'
 1227 |                         Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                 ^~~~~
p1153.cpp:1227:75: error: expected unqualified-id before ')' token
 1227 |                         Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                           ^
p1153.cpp:1228:12: error: 'input_range' has not been declared
 1228 |   template<input_range R1, random_access_range R2, class Comp = ranges::less,
      |            ^~~~~~~~~~~
p1153.cpp:1228:28: error: 'random_access_range' has not been declared
 1228 |   template<input_range R1, random_access_range R2, class Comp = ranges::less,
      |                            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1228:65: error: reference to 'ranges' is ambiguous
 1228 |   template<input_range R1, random_access_range R2, class Comp = ranges::less,
      |                                                                 ^~~~~~
/usr/local/include/c++/12.1.0/concepts:163:13: note: candidates are: 'namespace std::ranges { }'
  163 |   namespace ranges
      |             ^~~~~~
p1153.cpp:1180:11: note:                 'namespace ranges { }'
 1180 | namespace ranges {
      |           ^~~~~~
p1153.cpp:1228:71: error: expected '>' before '::' token
 1228 |   template<input_range R1, random_access_range R2, class Comp = ranges::less,
      |                                                                       ^~
p1153.cpp:1230:45: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |                                             ^~
      |                                             y1
p1153.cpp:1230:45: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |                                             ^~
      |                                             y1
p1153.cpp:1230:45: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |                                             ^~
      |                                             y1
p1153.cpp:1230:45: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |                                             ^~
      |                                             y1
p1153.cpp:1230:45: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |                                             ^~
      |                                             y1
p1153.cpp:1230:45: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |                                             ^~
      |                                             y1
p1153.cpp:1230:45: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |                                             ^~
      |                                             y1
p1153.cpp:1230:45: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |                                             ^~
      |                                             y1
p1153.cpp:1230:45: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |                                             ^~
      |                                             y1
p1153.cpp:1230:45: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |                                             ^~
      |                                             y1
p1153.cpp:1230:45: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |                                             ^~
      |                                             y1
p1153.cpp:1230:34: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |                                  ^~~~~~~~~~
      |                                  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>;
      |           ^~~~~~~~~~
p1153.cpp:1230:45: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |                                             ^~
      |                                             y1
p1153.cpp:1230:14: error: wrong number of template arguments (1, should be 2)
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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:
/usr/local/include/c++/12.1.0/bits/iterator_concepts.h:785:13: note: provided for 'template<class _In, class _Out> concept std::indirectly_copyable'
  785 |     concept indirectly_copyable = indirectly_readable<_In>
      |             ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1230:48: error: expected unqualified-id before ',' token
 1230 |     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
      |                                                ^
p1153.cpp:1235:56: error: expected unqualified-id before ',' token
 1235 | partial_sort_copy(R1&& r, R2&& result_r, Comp comp = {},
      |                                                        ^
p1153.cpp:1236:25: error: expected constructor, destructor, or type conversion before 'proj1'
 1236 |                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                         ^~~~~
p1153.cpp:1236:35: error: expected unqualified-id before ',' token
 1236 |                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                   ^
p1153.cpp:1236:43: error: expected constructor, destructor, or type conversion before 'proj2'
 1236 |                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                           ^~~~~
p1153.cpp:1236:53: error: expected unqualified-id before ')' token
 1236 |                   Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                     ^
p1153.cpp:1250:74: error: 'less' in namespace 'ranges::ranges' does not name a type
 1250 |            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
      |                                                                          ^~~~
p1153.cpp:1252:12: error: 'forward_range' has not been declared
 1252 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1253:60: error: 'R' was not declared in this scope
 1253 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1253:60: error: 'R' was not declared in this scope
p1153.cpp:1253:60: error: 'R' was not declared in this scope
p1153.cpp:1253:60: error: 'R' was not declared in this scope
p1153.cpp:1253:60: error: 'R' was not declared in this scope
p1153.cpp:1253:60: error: 'R' was not declared in this scope
p1153.cpp:1253:60: error: 'R' was not declared in this scope
p1153.cpp:1253:60: error: 'R' was not declared in this scope
p1153.cpp:1253:60: error: 'R' was not declared in this scope
p1153.cpp:1253:60: error: 'R' was not declared in this scope
p1153.cpp:1253:60: error: 'R' was not declared in this scope
p1153.cpp:1253:49: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1253 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1253:60: error: 'R' was not declared in this scope
 1253 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1253:61: error: wrong number of template arguments (1, should be 2)
 1253 |            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
      |            ^~~~~~~~~
p1153.cpp:1253:12: error: template argument 2 is invalid
 1253 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1253:71: error: 'Comp' does not name a type
 1253 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                       ^~~~
p1153.cpp:1254:51: error: expected unqualified-id before ',' token
 1254 |     constexpr bool is_sorted(R&& r, Comp comp = {}, Proj proj = {});
      |                                                   ^
p1153.cpp:1254:58: error: expected constructor, destructor, or type conversion before 'proj'
 1254 |     constexpr bool is_sorted(R&& r, Comp comp = {}, Proj proj = {});
      |                                                          ^~~~
p1153.cpp:1254:67: error: expected unqualified-id before ')' token
 1254 |     constexpr bool is_sorted(R&& r, Comp comp = {}, Proj proj = {});
      |                                                                   ^
p1153.cpp:1274:74: error: 'less' in namespace 'ranges::ranges' does not name a type
 1274 |            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
      |                                                                          ^~~~
p1153.cpp:1276:12: error: 'forward_range' has not been declared
 1276 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1277:60: error: 'R' was not declared in this scope
 1277 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1277:60: error: 'R' was not declared in this scope
p1153.cpp:1277:60: error: 'R' was not declared in this scope
p1153.cpp:1277:60: error: 'R' was not declared in this scope
p1153.cpp:1277:60: error: 'R' was not declared in this scope
p1153.cpp:1277:60: error: 'R' was not declared in this scope
p1153.cpp:1277:60: error: 'R' was not declared in this scope
p1153.cpp:1277:60: error: 'R' was not declared in this scope
p1153.cpp:1277:60: error: 'R' was not declared in this scope
p1153.cpp:1277:60: error: 'R' was not declared in this scope
p1153.cpp:1277:60: error: 'R' was not declared in this scope
p1153.cpp:1277:49: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1277 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1277:60: error: 'R' was not declared in this scope
 1277 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1277:61: error: wrong number of template arguments (1, should be 2)
 1277 |            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
      |            ^~~~~~~~~
p1153.cpp:1277:12: error: template argument 2 is invalid
 1277 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1277:71: error: 'Comp' does not name a type
 1277 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                       ^~~~
p1153.cpp:1279:44: error: expected unqualified-id before ',' token
 1279 |       is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                            ^
p1153.cpp:1279:51: error: expected constructor, destructor, or type conversion before 'proj'
 1279 |       is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                   ^~~~
p1153.cpp:1279:60: error: expected unqualified-id before ')' token
 1279 |       is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                            ^
p1153.cpp:1297:78: error: 'less' in namespace 'ranges::ranges' does not name a type
 1297 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                                              ^~~~
p1153.cpp:1302:12: error: 'random_access_range' has not been declared
 1302 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1302:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 1302 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                        ^~~~
p1153.cpp:1303:34: error: 'R' was not declared in this scope
 1303 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:1303:34: error: 'R' was not declared in this scope
p1153.cpp:1303:34: error: 'R' was not declared in this scope
p1153.cpp:1303:34: error: 'R' was not declared in this scope
p1153.cpp:1303:34: error: 'R' was not declared in this scope
p1153.cpp:1303:34: error: 'R' was not declared in this scope
p1153.cpp:1303:34: error: 'R' was not declared in this scope
p1153.cpp:1303:34: error: 'R' was not declared in this scope
p1153.cpp:1303:34: error: 'R' was not declared in this scope
p1153.cpp:1303:34: error: 'R' was not declared in this scope
p1153.cpp:1303:34: error: 'R' was not declared in this scope
p1153.cpp:1303:23: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1303 |     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>;
      |           ^~~~~~~~~~
p1153.cpp:1303:34: error: 'R' was not declared in this scope
 1303 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:1303:14: error: template argument 1 is invalid
 1303 |     requires sortable<iterator_t<R>, Comp, Proj>
      |              ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1303:36: error: expected unqualified-id before ',' token
 1303 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                    ^
p1153.cpp:1305:59: error: expected unqualified-id before ',' token
 1305 |       nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
      |                                                           ^
p1153.cpp:1305:66: error: expected constructor, destructor, or type conversion before 'proj'
 1305 |       nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
      |                                                                  ^~~~
p1153.cpp:1305:75: error: expected unqualified-id before ')' token
 1305 |       nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
      |                                                                           ^
p1153.cpp:1318:84: error: 'less' in namespace 'ranges::ranges' does not name a type
 1318 |            indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
      |                                                                                    ^~~~
p1153.cpp:1321:12: error: 'forward_range' has not been declared
 1321 |   template<forward_range R, class T, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1322:70: error: 'R' was not declared in this scope
 1322 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                      ^
p1153.cpp:1322:70: error: 'R' was not declared in this scope
p1153.cpp:1322:70: error: 'R' was not declared in this scope
p1153.cpp:1322:70: error: 'R' was not declared in this scope
p1153.cpp:1322:70: error: 'R' was not declared in this scope
p1153.cpp:1322:70: error: 'R' was not declared in this scope
p1153.cpp:1322:70: error: 'R' was not declared in this scope
p1153.cpp:1322:70: error: 'R' was not declared in this scope
p1153.cpp:1322:70: error: 'R' was not declared in this scope
p1153.cpp:1322:70: error: 'R' was not declared in this scope
p1153.cpp:1322:70: error: 'R' was not declared in this scope
p1153.cpp:1322:59: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1322 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1322:70: error: 'R' was not declared in this scope
 1322 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                      ^
p1153.cpp:1322:71: error: wrong number of template arguments (1, should be 2)
 1322 |            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
      |            ^~~~~~~~~
p1153.cpp:1322:12: error: wrong number of template arguments (4, should be at least 2)
 1322 |            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
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1322:81: error: 'Comp' does not name a type
 1322 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                                 ^~~~
p1153.cpp:1325:56: error: expected unqualified-id before ',' token
 1325 |       lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                        ^
p1153.cpp:1325:63: error: expected constructor, destructor, or type conversion before 'proj'
 1325 |       lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                               ^~~~
p1153.cpp:1325:72: error: expected unqualified-id before ')' token
 1325 |       lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                        ^
p1153.cpp:1337:84: error: 'less' in namespace 'ranges::ranges' does not name a type
 1337 |            indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
      |                                                                                    ^~~~
p1153.cpp:1339:12: error: 'forward_range' has not been declared
 1339 |   template<forward_range R, class T, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1340:70: error: 'R' was not declared in this scope
 1340 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                      ^
p1153.cpp:1340:70: error: 'R' was not declared in this scope
p1153.cpp:1340:70: error: 'R' was not declared in this scope
p1153.cpp:1340:70: error: 'R' was not declared in this scope
p1153.cpp:1340:70: error: 'R' was not declared in this scope
p1153.cpp:1340:70: error: 'R' was not declared in this scope
p1153.cpp:1340:70: error: 'R' was not declared in this scope
p1153.cpp:1340:70: error: 'R' was not declared in this scope
p1153.cpp:1340:70: error: 'R' was not declared in this scope
p1153.cpp:1340:70: error: 'R' was not declared in this scope
p1153.cpp:1340:70: error: 'R' was not declared in this scope
p1153.cpp:1340:59: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1340 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1340:70: error: 'R' was not declared in this scope
 1340 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                      ^
p1153.cpp:1340:71: error: wrong number of template arguments (1, should be 2)
 1340 |            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
      |            ^~~~~~~~~
p1153.cpp:1340:12: error: wrong number of template arguments (4, should be at least 2)
 1340 |            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
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1340:81: error: 'Comp' does not name a type
 1340 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                                 ^~~~
p1153.cpp:1343:56: error: expected unqualified-id before ',' token
 1343 |       upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                        ^
p1153.cpp:1343:63: error: expected constructor, destructor, or type conversion before 'proj'
 1343 |       upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                               ^~~~
p1153.cpp:1343:72: error: expected unqualified-id before ')' token
 1343 |       upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                        ^
p1153.cpp:1355:84: error: 'less' in namespace 'ranges::ranges' does not name a type
 1355 |            indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
      |                                                                                    ^~~~
p1153.cpp:1356:15: error: 'subrange' does not name a type
 1356 |     constexpr subrange<I>
      |               ^~~~~~~~
p1153.cpp:1357:66: error: expected unqualified-id before ',' token
 1357 |       equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                  ^
p1153.cpp:1357:73: error: expected constructor, destructor, or type conversion before 'proj'
 1357 |       equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                         ^~~~
p1153.cpp:1357:82: error: expected unqualified-id before ')' token
 1357 |       equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                                  ^
p1153.cpp:1358:12: error: 'forward_range' has not been declared
 1358 |   template<forward_range R, class T, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1359:70: error: 'R' was not declared in this scope
 1359 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                      ^
p1153.cpp:1359:70: error: 'R' was not declared in this scope
p1153.cpp:1359:70: error: 'R' was not declared in this scope
p1153.cpp:1359:70: error: 'R' was not declared in this scope
p1153.cpp:1359:70: error: 'R' was not declared in this scope
p1153.cpp:1359:70: error: 'R' was not declared in this scope
p1153.cpp:1359:70: error: 'R' was not declared in this scope
p1153.cpp:1359:70: error: 'R' was not declared in this scope
p1153.cpp:1359:70: error: 'R' was not declared in this scope
p1153.cpp:1359:70: error: 'R' was not declared in this scope
p1153.cpp:1359:70: error: 'R' was not declared in this scope
p1153.cpp:1359:59: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1359 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1359:70: error: 'R' was not declared in this scope
 1359 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                      ^
p1153.cpp:1359:71: error: wrong number of template arguments (1, should be 2)
 1359 |            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
      |            ^~~~~~~~~
p1153.cpp:1359:12: error: wrong number of template arguments (4, should be at least 2)
 1359 |            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
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1359:81: error: 'Comp' does not name a type
 1359 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                                 ^~~~
p1153.cpp:1362:56: error: expected unqualified-id before ',' token
 1362 |       equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                        ^
p1153.cpp:1362:63: error: expected constructor, destructor, or type conversion before 'proj'
 1362 |       equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                               ^~~~
p1153.cpp:1362:72: error: expected unqualified-id before ')' token
 1362 |       equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      |                                                                        ^
p1153.cpp:1374:84: error: 'less' in namespace 'ranges::ranges' does not name a type
 1374 |            indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
      |                                                                                    ^~~~
p1153.cpp:1377:12: error: 'forward_range' has not been declared
 1377 |   template<forward_range R, class T, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1378:70: error: 'R' was not declared in this scope
 1378 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                      ^
p1153.cpp:1378:70: error: 'R' was not declared in this scope
p1153.cpp:1378:70: error: 'R' was not declared in this scope
p1153.cpp:1378:70: error: 'R' was not declared in this scope
p1153.cpp:1378:70: error: 'R' was not declared in this scope
p1153.cpp:1378:70: error: 'R' was not declared in this scope
p1153.cpp:1378:70: error: 'R' was not declared in this scope
p1153.cpp:1378:70: error: 'R' was not declared in this scope
p1153.cpp:1378:70: error: 'R' was not declared in this scope
p1153.cpp:1378:70: error: 'R' was not declared in this scope
p1153.cpp:1378:70: error: 'R' was not declared in this scope
p1153.cpp:1378:59: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1378 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1378:70: error: 'R' was not declared in this scope
 1378 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                      ^
p1153.cpp:1378:71: error: wrong number of template arguments (1, should be 2)
 1378 |            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
      |            ^~~~~~~~~
p1153.cpp:1378:12: error: wrong number of template arguments (4, should be at least 2)
 1378 |            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
      |             ^~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1378:81: error: 'Comp' does not name a type
 1378 |            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
      |                                                                                 ^~~~
p1153.cpp:1380:71: error: expected unqualified-id before ',' token
 1380 |     constexpr bool binary_search(R&& r, const T& value, Comp comp = {},
      |                                                                       ^
p1153.cpp:1381:39: error: expected constructor, destructor, or type conversion before 'proj'
 1381 |                                  Proj proj = {});
      |                                       ^~~~
p1153.cpp:1381:48: error: expected unqualified-id before ')' token
 1381 |                                  Proj proj = {});
      |                                                ^
p1153.cpp:1393:12: error: 'input_range' has not been declared
 1393 |   template<input_range R, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:1394:58: error: 'R' was not declared in this scope
 1394 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                          ^
p1153.cpp:1394:58: error: 'R' was not declared in this scope
p1153.cpp:1394:58: error: 'R' was not declared in this scope
p1153.cpp:1394:58: error: 'R' was not declared in this scope
p1153.cpp:1394:58: error: 'R' was not declared in this scope
p1153.cpp:1394:58: error: 'R' was not declared in this scope
p1153.cpp:1394:58: error: 'R' was not declared in this scope
p1153.cpp:1394:58: error: 'R' was not declared in this scope
p1153.cpp:1394:58: error: 'R' was not declared in this scope
p1153.cpp:1394:58: error: 'R' was not declared in this scope
p1153.cpp:1394:58: error: 'R' was not declared in this scope
p1153.cpp:1394:47: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1394 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1394:58: error: 'R' was not declared in this scope
 1394 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                          ^
p1153.cpp:1394:59: error: wrong number of template arguments (1, should be 2)
 1394 |            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
      |            ^~~~~~~~~
p1153.cpp:1394:12: error: wrong number of template arguments (3, should be 2)
 1394 |            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>
      |             ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1394:69: error: 'Pred' does not name a type
 1394 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                                     ^~~~
p1153.cpp:1395:67: error: expected unqualified-id before ')' token
 1395 |     constexpr bool is_partitioned(R&& r, Pred pred, Proj proj = {});
      |                                                                   ^
p1153.cpp:1409:15: error: 'subrange' does not name a type
 1409 |     constexpr subrange<I>
      |               ^~~~~~~~
p1153.cpp:1410:53: error: expected unqualified-id before ')' token
 1410 | partition(I first, S last, Pred pred, Proj proj = {});
      |                                                     ^
p1153.cpp:1411:12: error: 'forward_range' has not been declared
 1411 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1412:58: error: 'R' was not declared in this scope
 1412 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                          ^
p1153.cpp:1412:58: error: 'R' was not declared in this scope
p1153.cpp:1412:58: error: 'R' was not declared in this scope
p1153.cpp:1412:58: error: 'R' was not declared in this scope
p1153.cpp:1412:58: error: 'R' was not declared in this scope
p1153.cpp:1412:58: error: 'R' was not declared in this scope
p1153.cpp:1412:58: error: 'R' was not declared in this scope
p1153.cpp:1412:58: error: 'R' was not declared in this scope
p1153.cpp:1412:58: error: 'R' was not declared in this scope
p1153.cpp:1412:58: error: 'R' was not declared in this scope
p1153.cpp:1412:58: error: 'R' was not declared in this scope
p1153.cpp:1412:47: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1412 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1412:58: error: 'R' was not declared in this scope
 1412 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                          ^
p1153.cpp:1412:59: error: wrong number of template arguments (1, should be 2)
 1412 |            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
      |            ^~~~~~~~~
p1153.cpp:1412:12: error: wrong number of template arguments (3, should be 2)
 1412 |            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>
      |             ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1412:69: error: 'Pred' does not name a type
 1412 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                                     ^~~~
p1153.cpp:1415:49: error: expected unqualified-id before ')' token
 1415 |       partition(R&& r, Pred pred, Proj proj = {});
      |                                                 ^
p1153.cpp:1430:5: error: 'subrange' does not name a type
 1430 |     subrange<I> stable_partition(I first, S last, Pred pred, Proj proj = {});
      |     ^~~~~~~~
p1153.cpp:1430:76: error: expected unqualified-id before ')' token
 1430 |     subrange<I> stable_partition(I first, S last, Pred pred, Proj proj = {});
      |                                                                            ^
p1153.cpp:1431:12: error: 'bidirectional_range' has not been declared
 1431 |   template<bidirectional_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1432:58: error: 'R' was not declared in this scope
 1432 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                          ^
p1153.cpp:1432:58: error: 'R' was not declared in this scope
p1153.cpp:1432:58: error: 'R' was not declared in this scope
p1153.cpp:1432:58: error: 'R' was not declared in this scope
p1153.cpp:1432:58: error: 'R' was not declared in this scope
p1153.cpp:1432:58: error: 'R' was not declared in this scope
p1153.cpp:1432:58: error: 'R' was not declared in this scope
p1153.cpp:1432:58: error: 'R' was not declared in this scope
p1153.cpp:1432:58: error: 'R' was not declared in this scope
p1153.cpp:1432:58: error: 'R' was not declared in this scope
p1153.cpp:1432:58: error: 'R' was not declared in this scope
p1153.cpp:1432:47: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1432 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1432:58: error: 'R' was not declared in this scope
 1432 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                          ^
p1153.cpp:1432:59: error: wrong number of template arguments (1, should be 2)
 1432 |            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
      |            ^~~~~~~~~
p1153.cpp:1432:12: error: wrong number of template arguments (3, should be 2)
 1432 |            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>
      |             ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1432:69: error: 'Pred' does not name a type
 1432 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                                     ^~~~
p1153.cpp:1434:77: error: expected unqualified-id before ')' token
 1434 |     borrowed_subrange_t<R> stable_partition(R&& r, Pred pred, Proj proj = {});
      |                                                                             ^
p1153.cpp:1451:35: error: 'in_out_out_result' does not name a type
 1451 |     using partition_copy_result = in_out_out_result<I, O1, O2>;
      |                                   ^~~~~~~~~~~~~~~~~
p1153.cpp:1456:15: error: 'partition_copy_result' does not name a type
 1456 |     constexpr partition_copy_result<I, O1, O2>
      |               ^~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1458:36: error: expected unqualified-id before ')' token
 1458 |                      Proj proj = {});
      |                                    ^
p1153.cpp:1459:12: error: 'input_range' has not been declared
 1459 |   template<input_range R, weakly_incrementable O1, weakly_incrementable O2,
      |            ^~~~~~~~~~~
p1153.cpp:1461:58: error: 'R' was not declared in this scope
 1461 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                          ^
p1153.cpp:1461:58: error: 'R' was not declared in this scope
p1153.cpp:1461:58: error: 'R' was not declared in this scope
p1153.cpp:1461:58: error: 'R' was not declared in this scope
p1153.cpp:1461:58: error: 'R' was not declared in this scope
p1153.cpp:1461:58: error: 'R' was not declared in this scope
p1153.cpp:1461:58: error: 'R' was not declared in this scope
p1153.cpp:1461:58: error: 'R' was not declared in this scope
p1153.cpp:1461:58: error: 'R' was not declared in this scope
p1153.cpp:1461:58: error: 'R' was not declared in this scope
p1153.cpp:1461:58: error: 'R' was not declared in this scope
p1153.cpp:1461:47: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1461 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1461:58: error: 'R' was not declared in this scope
 1461 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                          ^
p1153.cpp:1461:59: error: wrong number of template arguments (1, should be 2)
 1461 |            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
      |            ^~~~~~~~~
p1153.cpp:1461:12: error: wrong number of template arguments (3, should be 2)
 1461 |            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>
      |             ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1461:69: error: 'Pred' does not name a type
 1461 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                                     ^~~~
p1153.cpp:1466:15: error: expected constructor, destructor, or type conversion before '(' token
 1466 | partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
      |               ^
p1153.cpp:1466:75: error: expected unqualified-id before ')' token
 1466 | partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
      |                                                                           ^
p1153.cpp:1475:12: error: 'forward_range' has not been declared
 1475 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1476:58: error: 'R' was not declared in this scope
 1476 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                          ^
p1153.cpp:1476:58: error: 'R' was not declared in this scope
p1153.cpp:1476:58: error: 'R' was not declared in this scope
p1153.cpp:1476:58: error: 'R' was not declared in this scope
p1153.cpp:1476:58: error: 'R' was not declared in this scope
p1153.cpp:1476:58: error: 'R' was not declared in this scope
p1153.cpp:1476:58: error: 'R' was not declared in this scope
p1153.cpp:1476:58: error: 'R' was not declared in this scope
p1153.cpp:1476:58: error: 'R' was not declared in this scope
p1153.cpp:1476:58: error: 'R' was not declared in this scope
p1153.cpp:1476:58: error: 'R' was not declared in this scope
p1153.cpp:1476:47: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1476 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1476:58: error: 'R' was not declared in this scope
 1476 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                          ^
p1153.cpp:1476:59: error: wrong number of template arguments (1, should be 2)
 1476 |            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
      |            ^~~~~~~~~
p1153.cpp:1476:12: error: wrong number of template arguments (3, should be 2)
 1476 |            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>
      |             ^~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1476:69: error: 'Pred' does not name a type
 1476 |            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
      |                                                                     ^~~~
p1153.cpp:1478:55: error: expected unqualified-id before ')' token
 1478 |       partition_point(R&& r, Pred pred, Proj proj = {});
      |                                                       ^
p1153.cpp:1509:26: error: 'in_in_out_result' does not name a type
 1509 |     using merge_result = in_in_out_result<I1, I2, O>;
      |                          ^~~~~~~~~~~~~~~~
p1153.cpp:1513:55: error: 'less' in namespace 'ranges::ranges' does not name a type
 1513 |          weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity,
      |                                                       ^~~~
p1153.cpp:1516:13: error: 'merge_result' does not name a type
 1516 |   constexpr merge_result<I1, I2, O>
      |             ^~~~~~~~~~~~
p1153.cpp:1518:25: error: expected unqualified-id before ',' token
 1518 |           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                         ^
p1153.cpp:1518:33: error: expected constructor, destructor, or type conversion before 'proj1'
 1518 |           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                 ^~~~~
p1153.cpp:1518:43: error: expected unqualified-id before ',' token
 1518 |           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                           ^
p1153.cpp:1518:51: error: expected constructor, destructor, or type conversion before 'proj2'
 1518 |           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^~~~~
p1153.cpp:1518:61: error: expected unqualified-id before ')' token
 1518 |           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                             ^
p1153.cpp:1519:10: error: 'input_range' has not been declared
 1519 | template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
      |          ^~~~~~~~~~~
p1153.cpp:1519:26: error: 'input_range' has not been declared
 1519 | template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
      |                          ^~~~~~~~~~~
p1153.cpp:1519:87: error: 'less' in namespace 'ranges::ranges' does not name a type
 1519 | template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
      |                                                                                       ^~~~
p1153.cpp:1521:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1521 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1153.cpp:1521:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1521 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1153.cpp:1521:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1521 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1153.cpp:1521:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1521 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1153.cpp:1521:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1521 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1153.cpp:1521:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1521 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1153.cpp:1521:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1521 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1153.cpp:1521:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1521 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1153.cpp:1521:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1521 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1153.cpp:1521:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1521 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1153.cpp:1521:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1521 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1153.cpp:1521:22: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1521 |   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>;
      |           ^~~~~~~~~~
p1153.cpp:1521:33: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1521 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                 ^~
      |                                 y1
p1153.cpp:1521:12: error: wrong number of template arguments (1, should be at least 3)
 1521 |   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>
      |             ^~~~~~~~~
p1153.cpp:1521:36: error: expected unqualified-id before ',' token
 1521 |   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                    ^
p1153.cpp:1524:21: error: expected unqualified-id before ',' token
 1524 |       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                     ^
p1153.cpp:1524:29: error: expected constructor, destructor, or type conversion before 'proj1'
 1524 |       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                             ^~~~~
p1153.cpp:1524:39: error: expected unqualified-id before ',' token
 1524 |       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                       ^
p1153.cpp:1524:47: error: expected constructor, destructor, or type conversion before 'proj2'
 1524 |       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                               ^~~~~
p1153.cpp:1524:57: error: expected unqualified-id before ')' token
 1524 |       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                         ^
p1153.cpp:1544:78: error: 'less' in namespace 'ranges::ranges' does not name a type
 1544 |   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                                              ^~~~
p1153.cpp:1548:12: error: 'bidirectional_range' has not been declared
 1548 |   template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1548:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 1548 |   template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
      |                                                        ^~~~
p1153.cpp:1549:34: error: 'R' was not declared in this scope
 1549 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:1549:34: error: 'R' was not declared in this scope
p1153.cpp:1549:34: error: 'R' was not declared in this scope
p1153.cpp:1549:34: error: 'R' was not declared in this scope
p1153.cpp:1549:34: error: 'R' was not declared in this scope
p1153.cpp:1549:34: error: 'R' was not declared in this scope
p1153.cpp:1549:34: error: 'R' was not declared in this scope
p1153.cpp:1549:34: error: 'R' was not declared in this scope
p1153.cpp:1549:34: error: 'R' was not declared in this scope
p1153.cpp:1549:34: error: 'R' was not declared in this scope
p1153.cpp:1549:34: error: 'R' was not declared in this scope
p1153.cpp:1549:23: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1549 |     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>;
      |           ^~~~~~~~~~
p1153.cpp:1549:34: error: 'R' was not declared in this scope
 1549 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:1549:14: error: template argument 1 is invalid
 1549 |     requires sortable<iterator_t<R>, Comp, Proj>
      |              ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1549:36: error: expected unqualified-id before ',' token
 1549 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                    ^
p1153.cpp:1551:64: error: expected unqualified-id before ',' token
 1551 |       inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {},
      |                                                                ^
p1153.cpp:1552:26: error: expected constructor, destructor, or type conversion before 'proj'
 1552 |                     Proj proj = {});
      |                          ^~~~
p1153.cpp:1552:35: error: expected unqualified-id before ')' token
 1552 |                     Proj proj = {});
      |                                   ^
p1153.cpp:1576:22: error: 'less' in namespace 'ranges::ranges' does not name a type
 1576 |              ranges::less>
      |                      ^~~~
p1153.cpp:1579:12: error: 'input_range' has not been declared
 1579 |   template<input_range R1, input_range R2, class Proj1 = identity,
      |            ^~~~~~~~~~~
p1153.cpp:1579:28: error: 'input_range' has not been declared
 1579 |   template<input_range R1, input_range R2, class Proj1 = identity,
      |                            ^~~~~~~~~~~
p1153.cpp:1581:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1581 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:1581:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1581 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:1581:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1581 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:1581:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1581 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:1581:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1581 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:1581:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1581 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:1581:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1581 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:1581:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1581 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:1581:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1581 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:1581:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1581 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:1581:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1581 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:1581:49: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1581 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1581:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1581 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:1581:62: error: wrong number of template arguments (1, should be 2)
 1581 |            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
      |            ^~~~~~~~~
p1153.cpp:1581:12: error: template argument 2 is invalid
 1581 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1582:60: error: 'R2' was not declared in this scope
 1582 |                                       projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                            ^~
p1153.cpp:1582:60: error: 'R2' was not declared in this scope
p1153.cpp:1582:60: error: 'R2' was not declared in this scope
p1153.cpp:1582:60: error: 'R2' was not declared in this scope
p1153.cpp:1582:60: error: 'R2' was not declared in this scope
p1153.cpp:1582:60: error: 'R2' was not declared in this scope
p1153.cpp:1582:60: error: 'R2' was not declared in this scope
p1153.cpp:1582:60: error: 'R2' was not declared in this scope
p1153.cpp:1582:60: error: 'R2' was not declared in this scope
p1153.cpp:1582:60: error: 'R2' was not declared in this scope
p1153.cpp:1582:60: error: 'R2' was not declared in this scope
p1153.cpp:1582:49: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1582 |                                       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>;
      |           ^~~~~~~~~~
p1153.cpp:1582:60: error: 'R2' was not declared in this scope
 1582 |                                       projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                            ^~
p1153.cpp:1582:62: error: wrong number of template arguments (1, should be 2)
 1582 |                                       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
      |            ^~~~~~~~~
p1153.cpp:1582:70: error: expected '>' before '>>' token
 1582 |                                       projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                                      ^~
p1153.cpp:1582:73: error: 'Comp' does not name a type
 1582 |                                       projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                                         ^~~~
p1153.cpp:1583:61: error: expected unqualified-id before ',' token
 1583 |     constexpr bool includes(R1&& r1, R2&& r2, Comp comp = {},
      |                                                             ^
p1153.cpp:1584:1: error: expected unqualified-id before '}' token
 1584 | }
      | ^
p1153.cpp:1585:1: error: 'Proj1' does not name a type
 1585 | Proj1 proj1 = {}, Proj2 proj2 = {});
      | ^~~~~
p1153.cpp:1585:17: error: expected unqualified-id before ',' token
 1585 | Proj1 proj1 = {}, Proj2 proj2 = {});
      |                 ^
p1153.cpp:1585:25: error: expected constructor, destructor, or type conversion before 'proj2'
 1585 | Proj1 proj1 = {}, Proj2 proj2 = {});
      |                         ^~~~~
p1153.cpp:1585:35: error: expected unqualified-id before ')' token
 1585 | Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                   ^
p1153.cpp:1612:30: error: 'in_in_out_result' does not name a type
 1612 |     using set_union_result = in_in_out_result<I1, I2, O>;
      |                              ^~~~~~~~~~~~~~~~
p1153.cpp:1614:57: error: 'less' in namespace 'ranges::ranges' does not name a type
 1614 |            weakly_incrementable O, class Comp = ranges::less,
      |                                                         ^~~~
p1153.cpp:1617:15: error: 'set_union_result' does not name a type
 1617 |     constexpr set_union_result<I1, I2, O>
      |               ^~~~~~~~~~~~~~~~
p1153.cpp:1618:83: error: expected unqualified-id before ',' token
 1618 |       set_union(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {},
      |                                                                                   ^
p1153.cpp:1619:23: error: expected constructor, destructor, or type conversion before 'proj1'
 1619 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                       ^~~~~
p1153.cpp:1619:33: error: expected unqualified-id before ',' token
 1619 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                 ^
p1153.cpp:1619:41: error: expected constructor, destructor, or type conversion before 'proj2'
 1619 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                         ^~~~~
p1153.cpp:1619:51: error: expected unqualified-id before ')' token
 1619 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^
p1153.cpp:1620:12: error: 'input_range' has not been declared
 1620 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |            ^~~~~~~~~~~
p1153.cpp:1620:28: error: 'input_range' has not been declared
 1620 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |                            ^~~~~~~~~~~
p1153.cpp:1621:33: error: 'less' in namespace 'ranges::ranges' does not name a type
 1621 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                 ^~~~
p1153.cpp:1622:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1622 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1622:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1622 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1622:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1622 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1622:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1622 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1622:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1622 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1622:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1622 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1622:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1622 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1622:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1622 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1622:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1622 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1622:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1622 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1622:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1622 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1622:24: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1622 |     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>;
      |           ^~~~~~~~~~
p1153.cpp:1622:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1622 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1622:14: error: wrong number of template arguments (1, should be at least 3)
 1622 |     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>
      |             ^~~~~~~~~
p1153.cpp:1622:38: error: expected unqualified-id before ',' token
 1622 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                      ^
p1153.cpp:1624:59: error: expected unqualified-id before ',' token
 1624 |       set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
      |                                                           ^
p1153.cpp:1625:23: error: expected constructor, destructor, or type conversion before 'proj1'
 1625 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                       ^~~~~
p1153.cpp:1625:33: error: expected unqualified-id before ',' token
 1625 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                 ^
p1153.cpp:1625:41: error: expected constructor, destructor, or type conversion before 'proj2'
 1625 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                         ^~~~~
p1153.cpp:1625:51: error: expected unqualified-id before ')' token
 1625 |                 Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                   ^
p1153.cpp:1651:37: error: 'in_in_out_result' does not name a type
 1651 |     using set_intersection_result = in_in_out_result<I1, I2, O>;
      |                                     ^~~~~~~~~~~~~~~~
p1153.cpp:1653:57: error: 'less' in namespace 'ranges::ranges' does not name a type
 1653 |            weakly_incrementable O, class Comp = ranges::less,
      |                                                         ^~~~
p1153.cpp:1656:15: error: 'set_intersection_result' does not name a type
 1656 |     constexpr set_intersection_result<I1, I2, O>
      |               ^~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1658:38: error: expected unqualified-id before ',' token
 1658 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                      ^
p1153.cpp:1658:46: error: expected constructor, destructor, or type conversion before 'proj1'
 1658 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                              ^~~~~
p1153.cpp:1658:56: error: expected unqualified-id before ',' token
 1658 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                        ^
p1153.cpp:1658:64: error: expected constructor, destructor, or type conversion before 'proj2'
 1658 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                ^~~~~
p1153.cpp:1658:74: error: expected unqualified-id before ')' token
 1658 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                          ^
p1153.cpp:1659:12: error: 'input_range' has not been declared
 1659 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |            ^~~~~~~~~~~
p1153.cpp:1659:28: error: 'input_range' has not been declared
 1659 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |                            ^~~~~~~~~~~
p1153.cpp:1660:33: error: 'less' in namespace 'ranges::ranges' does not name a type
 1660 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                 ^~~~
p1153.cpp:1661:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1661 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1661:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1661 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1661:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1661 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1661:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1661 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1661:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1661 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1661:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1661 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1661:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1661 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1661:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1661 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1661:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1661 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1661:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1661 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1661:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1661 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1661:24: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1661 |     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>;
      |           ^~~~~~~~~~
p1153.cpp:1661:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1661 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1661:14: error: wrong number of template arguments (1, should be at least 3)
 1661 |     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>
      |             ^~~~~~~~~
p1153.cpp:1661:38: error: expected unqualified-id before ',' token
 1661 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                      ^
p1153.cpp:1664:38: error: expected unqualified-id before ',' token
 1664 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                      ^
p1153.cpp:1664:46: error: expected constructor, destructor, or type conversion before 'proj1'
 1664 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                              ^~~~~
p1153.cpp:1664:56: error: expected unqualified-id before ',' token
 1664 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                        ^
p1153.cpp:1664:64: error: expected constructor, destructor, or type conversion before 'proj2'
 1664 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                ^~~~~
p1153.cpp:1664:74: error: expected unqualified-id before ')' token
 1664 |                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                          ^
p1153.cpp:1690:35: error: 'in_out_result' does not name a type
 1690 |     using set_difference_result = in_out_result<I, O>;
      |                                   ^~~~~~~~~~~~~
p1153.cpp:1692:57: error: 'less' in namespace 'ranges::ranges' does not name a type
 1692 |            weakly_incrementable O, class Comp = ranges::less,
      |                                                         ^~~~
p1153.cpp:1695:15: error: 'set_difference_result' does not name a type
 1695 |     constexpr set_difference_result<I1, O>
      |               ^~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1697:36: error: expected unqualified-id before ',' token
 1697 |                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                    ^
p1153.cpp:1697:44: error: expected constructor, destructor, or type conversion before 'proj1'
 1697 |                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                            ^~~~~
p1153.cpp:1697:54: error: expected unqualified-id before ',' token
 1697 |                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                      ^
p1153.cpp:1697:62: error: expected constructor, destructor, or type conversion before 'proj2'
 1697 |                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                              ^~~~~
p1153.cpp:1697:72: error: expected unqualified-id before ')' token
 1697 |                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                        ^
p1153.cpp:1698:12: error: 'input_range' has not been declared
 1698 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |            ^~~~~~~~~~~
p1153.cpp:1698:28: error: 'input_range' has not been declared
 1698 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |                            ^~~~~~~~~~~
p1153.cpp:1699:33: error: 'less' in namespace 'ranges::ranges' does not name a type
 1699 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                 ^~~~
p1153.cpp:1700:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1700 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1700:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1700 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1700:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1700 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1700:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1700 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1700:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1700 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1700:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1700 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1700:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1700 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1700:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1700 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1700:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1700 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1700:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1700 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1700:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1700 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1700:24: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1700 |     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>;
      |           ^~~~~~~~~~
p1153.cpp:1700:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1700 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1700:14: error: wrong number of template arguments (1, should be at least 3)
 1700 |     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>
      |             ^~~~~~~~~
p1153.cpp:1700:38: error: expected unqualified-id before ',' token
 1700 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                      ^
p1153.cpp:1704:15: error: expected constructor, destructor, or type conversion before '(' token
 1704 | set_difference(R1&& r1, R2&& r2, O result,
      |               ^
p1153.cpp:1705:30: error: expected unqualified-id before ',' token
 1705 |                Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                              ^
p1153.cpp:1705:38: error: expected constructor, destructor, or type conversion before 'proj1'
 1705 |                Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                      ^~~~~
p1153.cpp:1705:48: error: expected unqualified-id before ',' token
 1705 |                Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                ^
p1153.cpp:1705:56: error: expected constructor, destructor, or type conversion before 'proj2'
 1705 |                Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                        ^~~~~
p1153.cpp:1705:66: error: expected unqualified-id before ')' token
 1705 |                Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                  ^
p1153.cpp:1730:45: error: 'in_in_out_result' does not name a type
 1730 |     using set_symmetric_difference_result = in_in_out_result<I1, I2, O>;
      |                                             ^~~~~~~~~~~~~~~~
p1153.cpp:1732:57: error: 'less' in namespace 'ranges::ranges' does not name a type
 1732 |            weakly_incrementable O, class Comp = ranges::less,
      |                                                         ^~~~
p1153.cpp:1735:15: error: 'set_symmetric_difference_result' does not name a type
 1735 |     constexpr set_symmetric_difference_result<I1, I2, O>
      |               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1737:46: error: expected unqualified-id before ',' token
 1737 |                                Comp comp = {}, Proj1 proj1 = {},
      |                                              ^
p1153.cpp:1737:54: error: expected constructor, destructor, or type conversion before 'proj1'
 1737 |                                Comp comp = {}, Proj1 proj1 = {},
      |                                                      ^~~~~
p1153.cpp:1737:64: error: expected unqualified-id before ',' token
 1737 |                                Comp comp = {}, Proj1 proj1 = {},
      |                                                                ^
p1153.cpp:1738:38: error: expected constructor, destructor, or type conversion before 'proj2'
 1738 |                                Proj2 proj2 = {});
      |                                      ^~~~~
p1153.cpp:1738:48: error: expected unqualified-id before ')' token
 1738 |                                Proj2 proj2 = {});
      |                                                ^
p1153.cpp:1739:12: error: 'input_range' has not been declared
 1739 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |            ^~~~~~~~~~~
p1153.cpp:1739:28: error: 'input_range' has not been declared
 1739 |   template<input_range R1, input_range R2, weakly_incrementable O,
      |                            ^~~~~~~~~~~
p1153.cpp:1740:33: error: 'less' in namespace 'ranges::ranges' does not name a type
 1740 |            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
      |                                 ^~~~
p1153.cpp:1741:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1741 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1741:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1741 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1741:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1741 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1741:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1741 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1741:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1741 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1741:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1741 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1741:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1741 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1741:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1741 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1741:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1741 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1741:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1741 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1741:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1741 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1741:24: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1741 |     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>;
      |           ^~~~~~~~~~
p1153.cpp:1741:35: error: 'R1' was not declared in this scope; did you mean 'y1'?
 1741 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                   ^~
      |                                   y1
p1153.cpp:1741:14: error: wrong number of template arguments (1, should be at least 3)
 1741 |     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>
      |             ^~~~~~~~~
p1153.cpp:1741:38: error: expected unqualified-id before ',' token
 1741 |     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
      |                                      ^
p1153.cpp:1744:68: error: expected unqualified-id before ',' token
 1744 | set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
      |                                                                    ^
p1153.cpp:1745:32: error: expected constructor, destructor, or type conversion before 'proj1'
 1745 |                          Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                ^~~~~
p1153.cpp:1745:42: error: expected unqualified-id before ',' token
 1745 |                          Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                          ^
p1153.cpp:1745:50: error: expected constructor, destructor, or type conversion before 'proj2'
 1745 |                          Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                  ^~~~~
p1153.cpp:1745:60: error: expected unqualified-id before ')' token
 1745 |                          Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                            ^
p1153.cpp:1753:78: error: 'less' in namespace 'ranges::ranges' does not name a type
 1753 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                                              ^~~~
p1153.cpp:1758:12: error: 'random_access_range' has not been declared
 1758 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1758:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 1758 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                        ^~~~
p1153.cpp:1759:34: error: 'R' was not declared in this scope
 1759 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:1759:34: error: 'R' was not declared in this scope
p1153.cpp:1759:34: error: 'R' was not declared in this scope
p1153.cpp:1759:34: error: 'R' was not declared in this scope
p1153.cpp:1759:34: error: 'R' was not declared in this scope
p1153.cpp:1759:34: error: 'R' was not declared in this scope
p1153.cpp:1759:34: error: 'R' was not declared in this scope
p1153.cpp:1759:34: error: 'R' was not declared in this scope
p1153.cpp:1759:34: error: 'R' was not declared in this scope
p1153.cpp:1759:34: error: 'R' was not declared in this scope
p1153.cpp:1759:34: error: 'R' was not declared in this scope
p1153.cpp:1759:23: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1759 |     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>;
      |           ^~~~~~~~~~
p1153.cpp:1759:34: error: 'R' was not declared in this scope
 1759 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:1759:14: error: template argument 1 is invalid
 1759 |     requires sortable<iterator_t<R>, Comp, Proj>
      |              ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1759:36: error: expected unqualified-id before ',' token
 1759 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                    ^
p1153.cpp:1761:38: error: expected unqualified-id before ',' token
 1761 |       push_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                      ^
p1153.cpp:1761:45: error: expected constructor, destructor, or type conversion before 'proj'
 1761 |       push_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                             ^~~~
p1153.cpp:1761:54: error: expected unqualified-id before ')' token
 1761 |       push_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                      ^
p1153.cpp:1769:78: error: 'less' in namespace 'ranges::ranges' does not name a type
 1769 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                                              ^~~~
p1153.cpp:1774:12: error: 'random_access_range' has not been declared
 1774 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1774:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 1774 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                        ^~~~
p1153.cpp:1775:34: error: 'R' was not declared in this scope
 1775 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:1775:34: error: 'R' was not declared in this scope
p1153.cpp:1775:34: error: 'R' was not declared in this scope
p1153.cpp:1775:34: error: 'R' was not declared in this scope
p1153.cpp:1775:34: error: 'R' was not declared in this scope
p1153.cpp:1775:34: error: 'R' was not declared in this scope
p1153.cpp:1775:34: error: 'R' was not declared in this scope
p1153.cpp:1775:34: error: 'R' was not declared in this scope
p1153.cpp:1775:34: error: 'R' was not declared in this scope
p1153.cpp:1775:34: error: 'R' was not declared in this scope
p1153.cpp:1775:34: error: 'R' was not declared in this scope
p1153.cpp:1775:23: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1775 |     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>;
      |           ^~~~~~~~~~
p1153.cpp:1775:34: error: 'R' was not declared in this scope
 1775 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:1775:14: error: template argument 1 is invalid
 1775 |     requires sortable<iterator_t<R>, Comp, Proj>
      |              ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1775:36: error: expected unqualified-id before ',' token
 1775 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                    ^
p1153.cpp:1777:37: error: expected unqualified-id before ',' token
 1777 |       pop_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                     ^
p1153.cpp:1777:44: error: expected constructor, destructor, or type conversion before 'proj'
 1777 |       pop_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                            ^~~~
p1153.cpp:1777:53: error: expected unqualified-id before ')' token
 1777 |       pop_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                     ^
p1153.cpp:1785:78: error: 'less' in namespace 'ranges::ranges' does not name a type
 1785 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                                              ^~~~
p1153.cpp:1790:12: error: 'random_access_range' has not been declared
 1790 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1790:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 1790 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                        ^~~~
p1153.cpp:1791:34: error: 'R' was not declared in this scope
 1791 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:1791:34: error: 'R' was not declared in this scope
p1153.cpp:1791:34: error: 'R' was not declared in this scope
p1153.cpp:1791:34: error: 'R' was not declared in this scope
p1153.cpp:1791:34: error: 'R' was not declared in this scope
p1153.cpp:1791:34: error: 'R' was not declared in this scope
p1153.cpp:1791:34: error: 'R' was not declared in this scope
p1153.cpp:1791:34: error: 'R' was not declared in this scope
p1153.cpp:1791:34: error: 'R' was not declared in this scope
p1153.cpp:1791:34: error: 'R' was not declared in this scope
p1153.cpp:1791:34: error: 'R' was not declared in this scope
p1153.cpp:1791:23: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1791 |     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>;
      |           ^~~~~~~~~~
p1153.cpp:1791:34: error: 'R' was not declared in this scope
 1791 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:1791:14: error: template argument 1 is invalid
 1791 |     requires sortable<iterator_t<R>, Comp, Proj>
      |              ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1791:36: error: expected unqualified-id before ',' token
 1791 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                    ^
p1153.cpp:1793:38: error: expected unqualified-id before ',' token
 1793 |       make_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                      ^
p1153.cpp:1793:45: error: expected constructor, destructor, or type conversion before 'proj'
 1793 |       make_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                             ^~~~
p1153.cpp:1793:54: error: expected unqualified-id before ')' token
 1793 |       make_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                      ^
p1153.cpp:1801:78: error: 'less' in namespace 'ranges::ranges' does not name a type
 1801 |   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                                              ^~~~
p1153.cpp:1806:12: error: 'random_access_range' has not been declared
 1806 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1806:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 1806 |   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
      |                                                        ^~~~
p1153.cpp:1807:34: error: 'R' was not declared in this scope
 1807 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:1807:34: error: 'R' was not declared in this scope
p1153.cpp:1807:34: error: 'R' was not declared in this scope
p1153.cpp:1807:34: error: 'R' was not declared in this scope
p1153.cpp:1807:34: error: 'R' was not declared in this scope
p1153.cpp:1807:34: error: 'R' was not declared in this scope
p1153.cpp:1807:34: error: 'R' was not declared in this scope
p1153.cpp:1807:34: error: 'R' was not declared in this scope
p1153.cpp:1807:34: error: 'R' was not declared in this scope
p1153.cpp:1807:34: error: 'R' was not declared in this scope
p1153.cpp:1807:34: error: 'R' was not declared in this scope
p1153.cpp:1807:23: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1807 |     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>;
      |           ^~~~~~~~~~
p1153.cpp:1807:34: error: 'R' was not declared in this scope
 1807 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:1807:14: error: template argument 1 is invalid
 1807 |     requires sortable<iterator_t<R>, Comp, Proj>
      |              ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1807:36: error: expected unqualified-id before ',' token
 1807 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                    ^
p1153.cpp:1809:38: error: expected unqualified-id before ',' token
 1809 |       sort_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                      ^
p1153.cpp:1809:45: error: expected constructor, destructor, or type conversion before 'proj'
 1809 |       sort_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                             ^~~~
p1153.cpp:1809:54: error: expected unqualified-id before ')' token
 1809 |       sort_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                      ^
p1153.cpp:1824:74: error: 'less' in namespace 'ranges::ranges' does not name a type
 1824 |            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
      |                                                                          ^~~~
p1153.cpp:1826:12: error: 'random_access_range' has not been declared
 1826 |   template<random_access_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1827:60: error: 'R' was not declared in this scope
 1827 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1827:60: error: 'R' was not declared in this scope
p1153.cpp:1827:60: error: 'R' was not declared in this scope
p1153.cpp:1827:60: error: 'R' was not declared in this scope
p1153.cpp:1827:60: error: 'R' was not declared in this scope
p1153.cpp:1827:60: error: 'R' was not declared in this scope
p1153.cpp:1827:60: error: 'R' was not declared in this scope
p1153.cpp:1827:60: error: 'R' was not declared in this scope
p1153.cpp:1827:60: error: 'R' was not declared in this scope
p1153.cpp:1827:60: error: 'R' was not declared in this scope
p1153.cpp:1827:60: error: 'R' was not declared in this scope
p1153.cpp:1827:49: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1827 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1827:60: error: 'R' was not declared in this scope
 1827 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1827:61: error: wrong number of template arguments (1, should be 2)
 1827 |            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
      |            ^~~~~~~~~
p1153.cpp:1827:12: error: template argument 2 is invalid
 1827 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1827:71: error: 'Comp' does not name a type
 1827 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                       ^~~~
p1153.cpp:1828:49: error: expected unqualified-id before ',' token
 1828 |     constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                 ^
p1153.cpp:1828:56: error: expected constructor, destructor, or type conversion before 'proj'
 1828 |     constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                        ^~~~
p1153.cpp:1828:65: error: expected unqualified-id before ')' token
 1828 |     constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});
      |                                                                 ^
p1153.cpp:1848:74: error: 'less' in namespace 'ranges::ranges' does not name a type
 1848 |            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
      |                                                                          ^~~~
p1153.cpp:1850:12: error: 'random_access_range' has not been declared
 1850 |   template<random_access_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:1851:60: error: 'R' was not declared in this scope
 1851 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1851:60: error: 'R' was not declared in this scope
p1153.cpp:1851:60: error: 'R' was not declared in this scope
p1153.cpp:1851:60: error: 'R' was not declared in this scope
p1153.cpp:1851:60: error: 'R' was not declared in this scope
p1153.cpp:1851:60: error: 'R' was not declared in this scope
p1153.cpp:1851:60: error: 'R' was not declared in this scope
p1153.cpp:1851:60: error: 'R' was not declared in this scope
p1153.cpp:1851:60: error: 'R' was not declared in this scope
p1153.cpp:1851:60: error: 'R' was not declared in this scope
p1153.cpp:1851:60: error: 'R' was not declared in this scope
p1153.cpp:1851:49: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1851 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1851:60: error: 'R' was not declared in this scope
 1851 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1851:61: error: wrong number of template arguments (1, should be 2)
 1851 |            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
      |            ^~~~~~~~~
p1153.cpp:1851:12: error: template argument 2 is invalid
 1851 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1851:71: error: 'Comp' does not name a type
 1851 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                       ^~~~
p1153.cpp:1853:42: error: expected unqualified-id before ',' token
 1853 |       is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                          ^
p1153.cpp:1853:49: error: expected constructor, destructor, or type conversion before 'proj'
 1853 |       is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                 ^~~~
p1153.cpp:1853:58: error: expected unqualified-id before ')' token
 1853 |       is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
      |                                                          ^
p1153.cpp:1864:81: error: 'less' in namespace 'ranges::ranges' does not name a type
 1864 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                                                                 ^~~~
p1153.cpp:1867:81: error: 'less' in namespace 'ranges::ranges' does not name a type
 1867 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                                                                 ^~~~
p1153.cpp:1869:12: error: 'input_range' has not been declared
 1869 |   template<input_range R, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:1870:60: error: 'R' was not declared in this scope
 1870 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1870:60: error: 'R' was not declared in this scope
p1153.cpp:1870:60: error: 'R' was not declared in this scope
p1153.cpp:1870:60: error: 'R' was not declared in this scope
p1153.cpp:1870:60: error: 'R' was not declared in this scope
p1153.cpp:1870:60: error: 'R' was not declared in this scope
p1153.cpp:1870:60: error: 'R' was not declared in this scope
p1153.cpp:1870:60: error: 'R' was not declared in this scope
p1153.cpp:1870:60: error: 'R' was not declared in this scope
p1153.cpp:1870:60: error: 'R' was not declared in this scope
p1153.cpp:1870:60: error: 'R' was not declared in this scope
p1153.cpp:1870:49: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1870 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1870:60: error: 'R' was not declared in this scope
 1870 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1870:61: error: wrong number of template arguments (1, should be 2)
 1870 |            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
      |            ^~~~~~~~~
p1153.cpp:1870:12: error: template argument 2 is invalid
 1870 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1870:71: error: 'Comp' does not name a type
 1870 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                       ^~~~
p1153.cpp:1873:32: error: expected unqualified-id before ',' token
 1873 |       min(R&& r, Comp comp = {}, Proj proj = {});
      |                                ^
p1153.cpp:1873:39: error: expected constructor, destructor, or type conversion before 'proj'
 1873 |       min(R&& r, Comp comp = {}, Proj proj = {});
      |                                       ^~~~
p1153.cpp:1873:48: error: expected unqualified-id before ')' token
 1873 |       min(R&& r, Comp comp = {}, Proj proj = {});
      |                                                ^
p1153.cpp:1884:81: error: 'less' in namespace 'ranges::ranges' does not name a type
 1884 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                                                                 ^~~~
p1153.cpp:1887:81: error: 'less' in namespace 'ranges::ranges' does not name a type
 1887 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                                                                 ^~~~
p1153.cpp:1889:12: error: 'input_range' has not been declared
 1889 |   template<input_range R, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:1890:60: error: 'R' was not declared in this scope
 1890 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1890:60: error: 'R' was not declared in this scope
p1153.cpp:1890:60: error: 'R' was not declared in this scope
p1153.cpp:1890:60: error: 'R' was not declared in this scope
p1153.cpp:1890:60: error: 'R' was not declared in this scope
p1153.cpp:1890:60: error: 'R' was not declared in this scope
p1153.cpp:1890:60: error: 'R' was not declared in this scope
p1153.cpp:1890:60: error: 'R' was not declared in this scope
p1153.cpp:1890:60: error: 'R' was not declared in this scope
p1153.cpp:1890:60: error: 'R' was not declared in this scope
p1153.cpp:1890:60: error: 'R' was not declared in this scope
p1153.cpp:1890:49: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1890 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1890:60: error: 'R' was not declared in this scope
 1890 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1890:61: error: wrong number of template arguments (1, should be 2)
 1890 |            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
      |            ^~~~~~~~~
p1153.cpp:1890:12: error: template argument 2 is invalid
 1890 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1890:71: error: 'Comp' does not name a type
 1890 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                       ^~~~
p1153.cpp:1893:32: error: expected unqualified-id before ',' token
 1893 |       max(R&& r, Comp comp = {}, Proj proj = {});
      |                                ^
p1153.cpp:1893:39: error: expected constructor, destructor, or type conversion before 'proj'
 1893 |       max(R&& r, Comp comp = {}, Proj proj = {});
      |                                       ^~~~
p1153.cpp:1893:48: error: expected unqualified-id before ')' token
 1893 |       max(R&& r, Comp comp = {}, Proj proj = {});
      |                                                ^
p1153.cpp:1904:27: error: 'min_max_result' does not name a type
 1904 |     using minmax_result = min_max_result<T>;
      |                           ^~~~~~~~~~~~~~
p1153.cpp:1906:81: error: 'less' in namespace 'ranges::ranges' does not name a type
 1906 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                                                                 ^~~~
p1153.cpp:1907:15: error: 'minmax_result' does not name a type
 1907 |     constexpr minmax_result<const T&>
      |               ^~~~~~~~~~~~~
p1153.cpp:1908:52: error: expected unqualified-id before ',' token
 1908 |       minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                    ^
p1153.cpp:1908:59: error: expected constructor, destructor, or type conversion before 'proj'
 1908 |       minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                           ^~~~
p1153.cpp:1908:68: error: expected unqualified-id before ')' token
 1908 |       minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
      |                                                                    ^
p1153.cpp:1910:81: error: 'less' in namespace 'ranges::ranges' does not name a type
 1910 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                                                                 ^~~~
p1153.cpp:1911:15: error: 'minmax_result' does not name a type
 1911 |     constexpr minmax_result<T>
      |               ^~~~~~~~~~~~~
p1153.cpp:1912:51: error: expected unqualified-id before ',' token
 1912 |       minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                   ^
p1153.cpp:1912:58: error: expected constructor, destructor, or type conversion before 'proj'
 1912 |       minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                          ^~~~
p1153.cpp:1912:67: error: expected unqualified-id before ')' token
 1912 |       minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
      |                                                                   ^
p1153.cpp:1913:12: error: 'input_range' has not been declared
 1913 |   template<input_range R, class Proj = identity,
      |            ^~~~~~~~~~~
p1153.cpp:1914:60: error: 'R' was not declared in this scope
 1914 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1914:60: error: 'R' was not declared in this scope
p1153.cpp:1914:60: error: 'R' was not declared in this scope
p1153.cpp:1914:60: error: 'R' was not declared in this scope
p1153.cpp:1914:60: error: 'R' was not declared in this scope
p1153.cpp:1914:60: error: 'R' was not declared in this scope
p1153.cpp:1914:60: error: 'R' was not declared in this scope
p1153.cpp:1914:60: error: 'R' was not declared in this scope
p1153.cpp:1914:60: error: 'R' was not declared in this scope
p1153.cpp:1914:60: error: 'R' was not declared in this scope
p1153.cpp:1914:60: error: 'R' was not declared in this scope
p1153.cpp:1914:49: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1914 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1914:60: error: 'R' was not declared in this scope
 1914 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1914:61: error: wrong number of template arguments (1, should be 2)
 1914 |            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
      |            ^~~~~~~~~
p1153.cpp:1914:12: error: template argument 2 is invalid
 1914 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1914:71: error: 'Comp' does not name a type
 1914 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                       ^~~~
p1153.cpp:1917:35: error: expected unqualified-id before ',' token
 1917 |       minmax(R&& r, Comp comp = {}, Proj proj = {});
      |                                   ^
p1153.cpp:1917:42: error: expected constructor, destructor, or type conversion before 'proj'
 1917 |       minmax(R&& r, Comp comp = {}, Proj proj = {});
      |                                          ^~~~
p1153.cpp:1917:51: error: expected unqualified-id before ')' token
 1917 |       minmax(R&& r, Comp comp = {}, Proj proj = {});
      |                                                   ^
p1153.cpp:1932:74: error: 'less' in namespace 'ranges::ranges' does not name a type
 1932 |            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
      |                                                                          ^~~~
p1153.cpp:1934:12: error: 'forward_range' has not been declared
 1934 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1935:60: error: 'R' was not declared in this scope
 1935 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1935:60: error: 'R' was not declared in this scope
p1153.cpp:1935:60: error: 'R' was not declared in this scope
p1153.cpp:1935:60: error: 'R' was not declared in this scope
p1153.cpp:1935:60: error: 'R' was not declared in this scope
p1153.cpp:1935:60: error: 'R' was not declared in this scope
p1153.cpp:1935:60: error: 'R' was not declared in this scope
p1153.cpp:1935:60: error: 'R' was not declared in this scope
p1153.cpp:1935:60: error: 'R' was not declared in this scope
p1153.cpp:1935:60: error: 'R' was not declared in this scope
p1153.cpp:1935:60: error: 'R' was not declared in this scope
p1153.cpp:1935:49: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1935 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1935:60: error: 'R' was not declared in this scope
 1935 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1935:61: error: wrong number of template arguments (1, should be 2)
 1935 |            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
      |            ^~~~~~~~~
p1153.cpp:1935:12: error: template argument 2 is invalid
 1935 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1935:71: error: 'Comp' does not name a type
 1935 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                       ^~~~
p1153.cpp:1937:40: error: expected unqualified-id before ',' token
 1937 |       min_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                        ^
p1153.cpp:1937:47: error: expected constructor, destructor, or type conversion before 'proj'
 1937 |       min_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                               ^~~~
p1153.cpp:1937:56: error: expected unqualified-id before ')' token
 1937 |       min_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                        ^
p1153.cpp:1952:74: error: 'less' in namespace 'ranges::ranges' does not name a type
 1952 |            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
      |                                                                          ^~~~
p1153.cpp:1954:12: error: 'forward_range' has not been declared
 1954 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1955:60: error: 'R' was not declared in this scope
 1955 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1955:60: error: 'R' was not declared in this scope
p1153.cpp:1955:60: error: 'R' was not declared in this scope
p1153.cpp:1955:60: error: 'R' was not declared in this scope
p1153.cpp:1955:60: error: 'R' was not declared in this scope
p1153.cpp:1955:60: error: 'R' was not declared in this scope
p1153.cpp:1955:60: error: 'R' was not declared in this scope
p1153.cpp:1955:60: error: 'R' was not declared in this scope
p1153.cpp:1955:60: error: 'R' was not declared in this scope
p1153.cpp:1955:60: error: 'R' was not declared in this scope
p1153.cpp:1955:60: error: 'R' was not declared in this scope
p1153.cpp:1955:49: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1955 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1955:60: error: 'R' was not declared in this scope
 1955 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1955:61: error: wrong number of template arguments (1, should be 2)
 1955 |            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
      |            ^~~~~~~~~
p1153.cpp:1955:12: error: template argument 2 is invalid
 1955 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1955:71: error: 'Comp' does not name a type
 1955 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                       ^~~~
p1153.cpp:1957:40: error: expected unqualified-id before ',' token
 1957 |       max_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                        ^
p1153.cpp:1957:47: error: expected constructor, destructor, or type conversion before 'proj'
 1957 |       max_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                               ^~~~
p1153.cpp:1957:56: error: expected unqualified-id before ')' token
 1957 |       max_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                        ^
p1153.cpp:1975:35: error: 'min_max_result' does not name a type
 1975 |     using minmax_element_result = min_max_result<I>;
      |                                   ^~~~~~~~~~~~~~
p1153.cpp:1977:74: error: 'less' in namespace 'ranges::ranges' does not name a type
 1977 |            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
      |                                                                          ^~~~
p1153.cpp:1978:15: error: 'minmax_element_result' does not name a type
 1978 |     constexpr minmax_element_result<I>
      |               ^~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1979:53: error: expected unqualified-id before ',' token
 1979 |       minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                     ^
p1153.cpp:1979:60: error: expected constructor, destructor, or type conversion before 'proj'
 1979 |       minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                            ^~~~
p1153.cpp:1979:69: error: expected unqualified-id before ')' token
 1979 |       minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                     ^
p1153.cpp:1980:12: error: 'forward_range' has not been declared
 1980 |   template<forward_range R, class Proj = identity,
      |            ^~~~~~~~~~~~~
p1153.cpp:1981:60: error: 'R' was not declared in this scope
 1981 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1981:60: error: 'R' was not declared in this scope
p1153.cpp:1981:60: error: 'R' was not declared in this scope
p1153.cpp:1981:60: error: 'R' was not declared in this scope
p1153.cpp:1981:60: error: 'R' was not declared in this scope
p1153.cpp:1981:60: error: 'R' was not declared in this scope
p1153.cpp:1981:60: error: 'R' was not declared in this scope
p1153.cpp:1981:60: error: 'R' was not declared in this scope
p1153.cpp:1981:60: error: 'R' was not declared in this scope
p1153.cpp:1981:60: error: 'R' was not declared in this scope
p1153.cpp:1981:60: error: 'R' was not declared in this scope
p1153.cpp:1981:49: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 1981 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:1981:60: error: 'R' was not declared in this scope
 1981 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                            ^
p1153.cpp:1981:61: error: wrong number of template arguments (1, should be 2)
 1981 |            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
      |            ^~~~~~~~~
p1153.cpp:1981:12: error: template argument 2 is invalid
 1981 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:1981:71: error: 'Comp' does not name a type
 1981 |            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
      |                                                                       ^~~~
p1153.cpp:1984:15: error: expected constructor, destructor, or type conversion before '(' token
 1984 | minmax_element(R&& r, Comp comp = {}, Proj proj = {});
      |               ^
p1153.cpp:1984:37: error: expected unqualified-id before ',' token
 1984 | minmax_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                     ^
p1153.cpp:1984:44: error: expected constructor, destructor, or type conversion before 'proj'
 1984 | minmax_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                            ^~~~
p1153.cpp:1984:53: error: expected unqualified-id before ')' token
 1984 | minmax_element(R&& r, Comp comp = {}, Proj proj = {});
      |                                                     ^
p1153.cpp:1992:81: error: 'less' in namespace 'ranges::ranges' does not name a type
 1992 |            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
      |                                                                                 ^~~~
p1153.cpp:2022:22: error: 'less' in namespace 'ranges::ranges' does not name a type
 2022 |              ranges::less>
      |                      ^~~~
p1153.cpp:2026:12: error: 'input_range' has not been declared
 2026 |   template<input_range R1, input_range R2, class Proj1 = identity,
      |            ^~~~~~~~~~~
p1153.cpp:2026:28: error: 'input_range' has not been declared
 2026 |   template<input_range R1, input_range R2, class Proj1 = identity,
      |                            ^~~~~~~~~~~
p1153.cpp:2028:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 2028 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:2028:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 2028 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:2028:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 2028 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:2028:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 2028 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:2028:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 2028 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:2028:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 2028 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:2028:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 2028 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:2028:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 2028 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:2028:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 2028 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:2028:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 2028 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:2028:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 2028 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:2028:49: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 2028 |            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>;
      |           ^~~~~~~~~~
p1153.cpp:2028:60: error: 'R1' was not declared in this scope; did you mean 'y1'?
 2028 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |                                                            ^~
      |                                                            y1
p1153.cpp:2028:62: error: wrong number of template arguments (1, should be 2)
 2028 |            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
      |            ^~~~~~~~~
p1153.cpp:2028:12: error: template argument 2 is invalid
 2028 |            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:2029:60: error: 'R2' was not declared in this scope
 2029 |                                       projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                            ^~
p1153.cpp:2029:60: error: 'R2' was not declared in this scope
p1153.cpp:2029:60: error: 'R2' was not declared in this scope
p1153.cpp:2029:60: error: 'R2' was not declared in this scope
p1153.cpp:2029:60: error: 'R2' was not declared in this scope
p1153.cpp:2029:60: error: 'R2' was not declared in this scope
p1153.cpp:2029:60: error: 'R2' was not declared in this scope
p1153.cpp:2029:60: error: 'R2' was not declared in this scope
p1153.cpp:2029:60: error: 'R2' was not declared in this scope
p1153.cpp:2029:60: error: 'R2' was not declared in this scope
p1153.cpp:2029:60: error: 'R2' was not declared in this scope
p1153.cpp:2029:49: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 2029 |                                       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>;
      |           ^~~~~~~~~~
p1153.cpp:2029:60: error: 'R2' was not declared in this scope
 2029 |                                       projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                            ^~
p1153.cpp:2029:62: error: wrong number of template arguments (1, should be 2)
 2029 |                                       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
      |            ^~~~~~~~~
p1153.cpp:2029:70: error: expected '>' before '>>' token
 2029 |                                       projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                                      ^~
p1153.cpp:2029:73: error: 'Comp' does not name a type
 2029 |                                       projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
      |                                                                         ^~~~
p1153.cpp:2031:63: error: expected unqualified-id before ',' token
 2031 |       lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
      |                                                               ^
p1153.cpp:2032:37: error: expected constructor, destructor, or type conversion before 'proj1'
 2032 |                               Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                     ^~~~~
p1153.cpp:2032:47: error: expected unqualified-id before ',' token
 2032 |                               Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                               ^
p1153.cpp:2032:55: error: expected constructor, destructor, or type conversion before 'proj2'
 2032 |                               Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                       ^~~~~
p1153.cpp:2032:65: error: expected unqualified-id before ')' token
 2032 |                               Proj1 proj1 = {}, Proj2 proj2 = {});
      |                                                                 ^
p1153.cpp:2038:1: error: expected identifier before '->' token
 2038 | -> decltype(comp(*b1, *b2));
      | ^~
p1153.cpp:2038:1: error: expected ',' or '...' before '->' token
p1153.cpp:2038:28: error: expected ')' before ';' token
 2038 | -> decltype(comp(*b1, *b2));
      |                            ^
      |                            )
p1153.cpp:2037:38: note: to match this '('
 2037 |     lexicographical_compare_three_way(InputIterator1 b1, InputIterator1 e1,
      |                                      ^
p1153.cpp:2039:1: error: 'InputIterator2' does not name a type
 2039 | InputIterator2 b2, InputIterator2 e2,
      | ^~~~~~~~~~~~~~
p1153.cpp:2041:3: error: expected declaration before '}' token
 2041 | } }
      |   ^
p1153.cpp:2042:1: error: 'Algorithm' does not name a type
 2042 | Algorithm result types
      | ^~~~~~~~~
p1153.cpp:2057:37: error: 'in_found_result' does not name a type
 2057 |     using next_permutation_result = in_found_result<I>;
      |                                     ^~~~~~~~~~~~~~~
p1153.cpp:2058:78: error: 'less' in namespace 'ranges::ranges' does not name a type
 2058 |   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                                              ^~~~
p1153.cpp:2061:15: error: 'next_permutation_result' does not name a type
 2061 |     constexpr next_permutation_result<I>
      |               ^~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:2062:55: error: expected unqualified-id before ',' token
 2062 |       next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                       ^
p1153.cpp:2062:62: error: expected constructor, destructor, or type conversion before 'proj'
 2062 |       next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                              ^~~~
p1153.cpp:2062:71: error: expected unqualified-id before ')' token
 2062 |       next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                       ^
p1153.cpp:2063:12: error: 'bidirectional_range' has not been declared
 2063 |   template<bidirectional_range R, class Comp = ranges::less,
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:2063:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 2063 |   template<bidirectional_range R, class Comp = ranges::less,
      |                                                        ^~~~
p1153.cpp:2065:34: error: 'R' was not declared in this scope
 2065 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:2065:34: error: 'R' was not declared in this scope
p1153.cpp:2065:34: error: 'R' was not declared in this scope
p1153.cpp:2065:34: error: 'R' was not declared in this scope
p1153.cpp:2065:34: error: 'R' was not declared in this scope
p1153.cpp:2065:34: error: 'R' was not declared in this scope
p1153.cpp:2065:34: error: 'R' was not declared in this scope
p1153.cpp:2065:34: error: 'R' was not declared in this scope
p1153.cpp:2065:34: error: 'R' was not declared in this scope
p1153.cpp:2065:34: error: 'R' was not declared in this scope
p1153.cpp:2065:34: error: 'R' was not declared in this scope
p1153.cpp:2065:23: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 2065 |     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>;
      |           ^~~~~~~~~~
p1153.cpp:2065:34: error: 'R' was not declared in this scope
 2065 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:2065:14: error: template argument 1 is invalid
 2065 |     requires sortable<iterator_t<R>, Comp, Proj>
      |              ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:2065:36: error: expected unqualified-id before ',' token
 2065 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                    ^
p1153.cpp:2067:45: error: expected unqualified-id before ',' token
 2067 |       next_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                             ^
p1153.cpp:2067:52: error: expected constructor, destructor, or type conversion before 'proj'
 2067 |       next_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                                    ^~~~
p1153.cpp:2067:61: error: expected unqualified-id before ')' token
 2067 |       next_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                                             ^
p1153.cpp:2077:37: error: 'in_found_result' does not name a type
 2077 |     using prev_permutation_result = in_found_result<I>;
      |                                     ^~~~~~~~~~~~~~~
p1153.cpp:2078:78: error: 'less' in namespace 'ranges::ranges' does not name a type
 2078 |   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
      |                                                                              ^~~~
p1153.cpp:2081:15: error: 'prev_permutation_result' does not name a type
 2081 |     constexpr prev_permutation_result<I>
      |               ^~~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:2082:55: error: expected unqualified-id before ',' token
 2082 |       prev_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                       ^
p1153.cpp:2082:62: error: expected constructor, destructor, or type conversion before 'proj'
 2082 |       prev_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                              ^~~~
p1153.cpp:2082:71: error: expected unqualified-id before ')' token
 2082 |       prev_permutation(I first, S last, Comp comp = {}, Proj proj = {});
      |                                                                       ^
p1153.cpp:2083:12: error: 'bidirectional_range' has not been declared
 2083 |   template<bidirectional_range R, class Comp = ranges::less,
      |            ^~~~~~~~~~~~~~~~~~~
p1153.cpp:2083:56: error: 'less' in namespace 'ranges::ranges' does not name a type
 2083 |   template<bidirectional_range R, class Comp = ranges::less,
      |                                                        ^~~~
p1153.cpp:2085:34: error: 'R' was not declared in this scope
 2085 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:2085:34: error: 'R' was not declared in this scope
p1153.cpp:2085:34: error: 'R' was not declared in this scope
p1153.cpp:2085:34: error: 'R' was not declared in this scope
p1153.cpp:2085:34: error: 'R' was not declared in this scope
p1153.cpp:2085:34: error: 'R' was not declared in this scope
p1153.cpp:2085:34: error: 'R' was not declared in this scope
p1153.cpp:2085:34: error: 'R' was not declared in this scope
p1153.cpp:2085:34: error: 'R' was not declared in this scope
p1153.cpp:2085:34: error: 'R' was not declared in this scope
p1153.cpp:2085:34: error: 'R' was not declared in this scope
p1153.cpp:2085:23: error: 'iterator_t' was not declared in this scope; did you mean 'std::ranges::iterator_'?
 2085 |     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>;
      |           ^~~~~~~~~~
p1153.cpp:2085:34: error: 'R' was not declared in this scope
 2085 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                  ^
p1153.cpp:2085:14: error: template argument 1 is invalid
 2085 |     requires sortable<iterator_t<R>, Comp, Proj>
      |              ^~~~~~~~~~~~~~~~~~~~~~
p1153.cpp:2085:36: error: expected unqualified-id before ',' token
 2085 |     requires sortable<iterator_t<R>, Comp, Proj>
      |                                    ^
p1153.cpp:2087:40: error: expected unqualified-id before ',' token
 2087 |  prev_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                        ^
p1153.cpp:2087:47: error: expected constructor, destructor, or type conversion before 'proj'
 2087 |  prev_permutation(R&& r, Comp comp = {}, Proj proj = {});
      |                                               ^~~~
p1153.cpp:2087:56: error: expected unqualified-id before ')' token
 2087 |  prev_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 初稿 　20220814