23.4 String classes [string.classes] C++N4910:2022 (636) p808.cpp

# はじめに(Introduction)
N4910  Working Draft, Standard for Programming Language C++
http://www.open-std./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.

# 23.4 String classes [string.classes] C++N4910:2022 (636) p808.cpp

## 算譜(source code)

```c++:p808.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 = "23.4 String classes [string.classes] C++N4910:2022 (636) p808.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;

// 23.4.2 Header <string> synopsis [string.syn]
#include <compare> // see 17.11.1
#include <initializer_list> // see 17.10.2
namespace std {
// 23.2, character traits
template<class charT> struct char_traits;
template<> struct char_traits<char>;
template<> struct char_traits<char8_t>;
template<> struct char_traits<char16_t>;
template<> struct char_traits<char32_t>;
template<> struct char_traits<wchar_t>;
// 23.4.3, basic_string
template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
class basic_string;
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs,
          const basic_string<charT, traits, Allocator>& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs,
          const basic_string<charT, traits, Allocator>& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs,
          basic_string<charT, traits, Allocator>&& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs,
          basic_string<charT, traits, Allocator>&& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const charT* lhs,
          const basic_string<charT, traits, Allocator>& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const charT* lhs,
          basic_string<charT, traits, Allocator>&& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(charT lhs,
          const basic_string<charT, traits, Allocator>& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(charT lhs,
          basic_string<charT, traits, Allocator>&& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs,
          const charT* rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs,
          const charT* rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs,
          charT rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs,
          charT rhs);
template<class charT, class traits, class Allocator>
constexpr bool
operator==(const basic_string<charT, traits, Allocator>& lhs,
           const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
                          const charT* rhs);
template<class charT, class traits, class Allocator>
constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
                                const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
// 23.4.4.3, swap
template<class charT, class traits, class Allocator>
constexpr void
swap(basic_string<charT, traits, Allocator>& lhs,
     basic_string<charT, traits, Allocator>& rhs)
noexcept(noexcept(lhs.swap(rhs)));
// 23.4.4.4, inserters and extractors
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
           basic_string<charT, traits, Allocator>& str);
template<class charT, class traits, class Allocator>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
           const basic_string<charT, traits, Allocator>& str);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
        basic_string<charT, traits, Allocator>& str,
        charT delim);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>&& is,
        basic_string<charT, traits, Allocator>& str,
        charT delim);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
        basic_string<charT, traits, Allocator>& str);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>&& is,
        basic_string<charT, traits, Allocator>& str);
// 23.4.4.5, erasure
template<class charT, class traits, class Allocator, class U>
constexpr typename basic_string<charT, traits, Allocator>::size_type
erase(basic_string<charT, traits, Allocator>& c, const U& value);
template<class charT, class traits, class Allocator, class Predicate>
constexpr typename basic_string<charT, traits, Allocator>::size_type
erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred);
// basic_string typedef-names
using string = basic_string<char>;
using u8string = basic_string<char8_t>;
using u16string = basic_string<char16_t>;
using u32string = basic_string<char32_t>;
using wstring = basic_string<wchar_t>;
// 23.4.5, numeric conversions
int stoi(const string& str, size_t* idx = nullptr, int base = 10);
long stol(const string& str, size_t* idx = nullptr, int base = 10);
unsigned long stoul(const string& str, size_t* idx = nullptr, int base = 10);
long long stoll(const string& str, size_t* idx = nullptr, int base = 10);
unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10);
float stof(const string& str, size_t* idx = nullptr);
double stod(const string& str, size_t* idx = nullptr);
long double stold(const string& str, size_t* idx = nullptr);
string to_string(int val);
string to_string(unsigned val);
string to_string(long val);
string to_string(unsigned long val);
string to_string(long long val);
string to_string(unsigned long long val);
string to_string(float val);
string to_string(double val);
string to_string(long double val);
int stoi(const wstring& str, size_t* idx = nullptr, int base = 10);
long stol(const wstring& str, size_t* idx = nullptr, int base = 10);
unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);
long long stoll(const wstring& str, size_t* idx = nullptr, int base = 10);
unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);
float stof(const wstring& str, size_t* idx = nullptr);
double stod(const wstring& str, size_t* idx = nullptr);
long double stold(const wstring& str, size_t* idx = nullptr);
wstring to_wstring(int val);
wstring to_wstring(unsigned val);
wstring to_wstring(long val);
wstring to_wstring(unsigned long val);
wstring to_wstring(long long val);
wstring to_wstring(unsigned long long val);
wstring to_wstring(float val);
wstring to_wstring(double val);
wstring to_wstring(long double val);
namespace pmr {
template<class charT, class traits = char_traits<charT>>
using basic_string = std::basic_string<charT, traits, polymorphic_allocator<charT>>;
using string    = basic_string<char>;
using u8string  = basic_string<char8_t>;
using u16string = basic_string<char16_t>;
using u32string = basic_string<char32_t>;
using wstring   = basic_string<wchar_t>;
}
// 23.4.6, hash support
template<class T> struct hash;
template<> struct hash<string>;
template<> struct hash<u8string>;
template<> struct hash<u16string>;
template<> struct hash<u32string>;
template<> struct hash<wstring>;
template<> struct hash<pmr::string>;
template<> struct hash<pmr::u8string>;
template<> struct hash<pmr::u16string>;
template<> struct hash<pmr::u32string>;
template<> struct hash<pmr::wstring>;
inline namespace literals {
inline namespace string_literals {
// 23.4.7, suffix for basic_string literals
constexpr string operator""s(const char* str, size_t len);
constexpr u8string operator""s(const char8_t* str, size_t len);
constexpr u16string operator""s(const char16_t* str, size_t len);
constexpr u32string operator""s(const char32_t* str, size_t len);
constexpr wstring operator""s(const wchar_t* str, size_t len);
}
}
}
// 23.4.3 Class template basic_string [basic.string]
// 23.4.3.1 General [basic.string.general]
//  The class template basic_string describes objects that can store a sequence consisting of a varying number of arbitrary char-like objects with the first element of the sequence at position zero. Such a sequence is also called a “string” if the type of the char-like objects that it holds is clear from context. In the rest of 23.4.3, the type of the char-like objects held in a basic_string object is designated by charT.
//  A specialization of basic_string is a contiguous container (24.2.2.1).
//  In all cases, [data(), data() + size()] is a valid range, data() + size() points at an object with value charT() (a “null terminator”), and size() <= capacity() is true.
namespace std {
template<class charT, class traits = char_traits<charT>,
         class Allocator = allocator<charT>>
class basic_string {
public:
// types
    using traits_type = traits;
    using value_type = charT;
    using allocator_type = Allocator;
    using size_type = typename allocator_traits<Allocator>::size_type;
    using difference_type = typename allocator_traits<Allocator>::difference_type;
    using pointer = typename allocator_traits<Allocator>::pointer;
    using const_pointer = typename allocator_traits<Allocator>::const_pointer;
    using reference = value_type&;
    using const_reference = const value_type&;
    using iterator = implementation-defined ; // see 24.2
    using const_iterator = implementation-defined ; // see 24.2
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    static constexpr size_type npos = size_type(-1);
// 23.4.3.3, construct/copy/destroy
    constexpr basic_string() noexcept(noexcept(Allocator())) : basic_string(Allocator()) { } constexpr explicit basic_string(const Allocator& a) noexcept;
    constexpr basic_string(const basic_string& str);
    constexpr basic_string(basic_string&& str) noexcept;
    constexpr basic_string(const basic_string& str, size_type pos,
                           const Allocator& a = Allocator());
    constexpr basic_string(const basic_string& str, size_type pos, size_type n,
                           const Allocator& a = Allocator());
    template<class T>
    constexpr basic_string(const T& t, size_type pos, size_type n,
                           const Allocator& a = Allocator());
    template<class T>
    constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
    constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
    constexpr basic_string(const charT* s, const Allocator& a = Allocator());
    basic_string(nullptr_t) = delete;
    constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
    template<class InputIterator>
    constexpr basic_string(InputIterator begin, InputIterator end,
                           const Allocator& a = Allocator());
    template<container-compatible-range<charT> R>
    constexpr basic_string(from_range_t, R&& rg, const Allocator& a = Allocator());
    constexpr basic_string(initializer_list<charT>, const Allocator& = Allocator());
    constexpr basic_string(const basic_string&, const Allocator&);
    constexpr basic_string(basic_string&&, const Allocator&);
    constexpr ~basic_string();
    constexpr basic_string& operator=(const basic_string& str);
    constexpr basic_string& operator=(basic_string&& str)
    noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
             allocator_traits<Allocator>::is_always_equal::value);
    template<class T>
    constexpr basic_string& operator=(const T& t);
    constexpr basic_string& operator=(const charT* s);
    basic_string& operator=(nullptr_t) = delete;
    constexpr basic_string& operator=(charT c);
    constexpr basic_string& operator=(initializer_list<charT>);
// 23.4.3.4, iterators
    constexpr iterator begin() noexcept;
    constexpr const_iterator begin() const noexcept;
    constexpr iterator end() noexcept;
    constexpr const_iterator end() const noexcept;
    constexpr reverse_iterator       rbegin() noexcept;
    constexpr const_reverse_iterator rbegin() const noexcept;
    constexpr reverse_iterator       rend() noexcept;
    constexpr const_reverse_iterator rend() const noexcept;
    constexpr const_iterator         cbegin() const noexcept;
    constexpr const_iterator         cend() const noexcept;
    constexpr const_reverse_iterator crbegin() const noexcept;
    constexpr const_reverse_iterator crend() const noexcept;
// 23.4.3.5, capacity
    constexpr size_type size() const noexcept;
    constexpr size_type length() const noexcept;
    constexpr size_type max_size() const noexcept;
    constexpr void resize(size_type n, charT c);
    constexpr void resize(size_type n);
    template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
    constexpr size_type capacity() const noexcept;
    constexpr void reserve(size_type res_arg);
    constexpr void shrink_to_fit();
    constexpr void clear() noexcept;
    [[nodiscard]] constexpr bool empty() const noexcept;
// 23.4.3.6, element access
    constexpr const_reference operator[](size_type pos) const;
    constexpr reference operator[](size_type pos);
    constexpr const_reference at(size_type n) const;
    constexpr reference at(size_type n);
    constexpr const charT& front() const;
    constexpr charT&       front();
    constexpr const charT& back() const;
    constexpr charT&       back();
// 23.4.3.7, modifiers
    constexpr basic_string& operator+=(const basic_string& str);
    template<class T>
    constexpr basic_string& operator+=(const T& t);
    constexpr basic_string& operator+=(const charT* s);
    constexpr basic_string& operator+=(charT c);
    constexpr basic_string& operator+=(initializer_list<charT>);
    constexpr basic_string& append(const basic_string& str);
    constexpr basic_string& append(const basic_string& str, size_type pos, size_type n = npos);
    template<class T>
    constexpr basic_string& append(const T& t);
    template<class T>
    constexpr basic_string& append(const T& t, size_type pos, size_type n = npos);
    constexpr basic_string& append(const charT* s, size_type n);
    constexpr basic_string& append(const charT* s);
    constexpr basic_string& append(size_type n, charT c);
    template<class InputIterator>
    constexpr basic_string& append(InputIterator first, InputIterator last);
    template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
    constexpr basic_string& append(initializer_list<charT>);
    constexpr void push_back(charT c);
    constexpr basic_string& assign(const basic_string& str);
    constexpr basic_string& assign(basic_string&& str)
    noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
             allocator_traits<Allocator>::is_always_equal::value);
    constexpr basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);
    template<class T>
    constexpr basic_string& assign(const T& t);
    template<class T>
    constexpr basic_string& assign(const T& t, size_type pos, size_type n = npos);
    constexpr basic_string& assign(const charT* s, size_type n);
    constexpr basic_string& assign(const charT* s);
    constexpr basic_string& assign(size_type n, charT c);
    template<class InputIterator>
    constexpr basic_string& assign(InputIterator first, InputIterator last);
    template<container-compatible-range<charT> R>
    constexpr basic_string& assign_range(R&& rg);
    constexpr basic_string& assign(initializer_list<charT>);
    constexpr basic_string& insert(size_type pos, const basic_string& str);
    constexpr basic_string& insert(size_type pos1, const basic_string& str,
                                   size_type pos2, size_type n = npos);
    template<class T>
    constexpr basic_string& insert(size_type pos, const T& t);
    template<class T>
    constexpr basic_string& insert(size_type pos1, const T& t,
                                   size_type pos2, size_type n = npos);
    constexpr basic_string& insert(size_type pos, const charT* s, size_type n);
    constexpr basic_string& insert(size_type pos, const charT* s);
    constexpr basic_string& insert(size_type pos, size_type n, charT c);
    constexpr iterator insert(const_iterator p, charT c);
    constexpr iterator insert(const_iterator p, size_type n, charT c);
    template<class InputIterator>
    constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
    template<container-compatible-range<charT> R>
    constexpr iterator insert_range(const_iterator p, R&& rg);
    constexpr iterator insert(const_iterator p, initializer_list<charT>);
    constexpr basic_string& erase(size_type pos = 0, size_type n = npos);
    constexpr iterator erase(const_iterator p);
    constexpr iterator erase(const_iterator first, const_iterator last);
    constexpr void pop_back();
    constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
    constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
                                    size_type pos2, size_type n2 = npos);
    template<class T>
    constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);
    template<class T>
    constexpr basic_string& replace(size_type pos1, size_type n1, const T& t,
                                    size_type pos2, size_type n2 = npos);
    constexpr basic_string& replace(size_type pos, size_type n1, const charT* s, size_type n2);
    constexpr basic_string& replace(size_type pos, size_type n1, const charT* s);
    constexpr basic_string& replace(size_type pos, size_type n1, size_type n2, charT c);
    constexpr basic_string& replace(const_iterator i1, const_iterator i2,
                                    const basic_string& str);
    template<class T>
    constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);
    constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s,
                                    size_type n);
    constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
    constexpr basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);
    template<class InputIterator>
    constexpr basic_string& replace(const_iterator i1, const_iterator i2,
                                    InputIterator j1, InputIterator j2);
    template<container-compatible-range<charT> R>
    constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg);
    constexpr basic_string& replace(const_iterator, const_iterator, initializer_list<charT>);
    constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
    constexpr void swap(basic_string& str)
    noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
             allocator_traits<Allocator>::is_always_equal::value);
// 23.4.3.8, string operations
    constexpr const charT* c_str() const noexcept;
    constexpr const charT* data() const noexcept;
    constexpr charT* data() noexcept;
    constexpr operator basic_string_view<charT, traits>() const noexcept;
    constexpr allocator_type get_allocator() const noexcept;
    template<class T>
    constexpr size_type find(const T& t, size_type pos = 0) const noexcept(see below);
    constexpr size_type find(const basic_string& str, size_type pos = 0) const noexcept;
    constexpr size_type find(const charT* s, size_type pos, size_type n) const;
    constexpr size_type find(const charT* s, size_type pos = 0) const;
    constexpr size_type find(charT c, size_type pos = 0) const noexcept;
    template<class T>
    constexpr size_type rfind(const T& t, size_type pos = npos) const noexcept(see below);
    constexpr size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
    constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
    constexpr size_type rfind(const charT* s, size_type pos = npos) const;
    constexpr size_type rfind(charT c, size_type pos = npos) const noexcept;
    template<class T>
    constexpr size_type find_first_of(const T& t, size_type pos = 0) const noexcept(see below);
    constexpr size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;
    constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
    constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
    constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept;
    template<class T>
    constexpr size_type find_last_of(const T& t,
                                     size_type pos = npos) const noexcept(see below);
    constexpr size_type find_last_of(const basic_string& str,
                                     size_type pos = npos) const noexcept;
    constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
    constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
    constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept;
    template<class T>
    constexpr size_type find_first_not_of(const T& t,
                                          size_type pos = 0) const noexcept(see below);
    constexpr size_type find_first_not_of(const basic_string& str,
                                          size_type pos = 0) const noexcept;
    constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
    constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
    constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;
    template<class T>
    constexpr size_type find_last_not_of(const T& t,
                                         size_type pos = npos) const noexcept(see below);
    constexpr size_type find_last_not_of(const basic_string& str,
                                         size_type pos = npos) const noexcept;
    constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
    constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;
    constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
    constexpr basic_string substr(size_type pos = 0, size_type n = npos) const;
    template<class T>
    constexpr int compare(const T& t) const noexcept(see below);
    template<class T>
    constexpr int compare(size_type pos1, size_type n1, const T& t) const;
}
template<class T>
constexpr int compare(size_type pos1, size_type n1, const T& t,
                      size_type pos2, size_type n2 = npos) const;
constexpr int compare(const basic_string& str) const noexcept;
constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
                      size_type pos2, size_type n2 = npos) const;
constexpr int compare(const charT* s) const;
constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
constexpr bool starts_with(charT x) const noexcept;
constexpr bool starts_with(const charT* x) const;
constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
constexpr bool ends_with(charT x) const noexcept;
constexpr bool ends_with(const charT* x) const;
constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
constexpr bool contains(charT x) const noexcept;
constexpr bool contains(const charT* x) const;
};
template<class InputIterator,
         class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
basic_string(InputIterator, InputIterator, Allocator = Allocator())
-> basic_string<typename iterator_traits<InputIterator>::value_type,
    char_traits<typename iterator_traits<InputIterator>::value_type>,
    Allocator>;
template<ranges::input_range R,
         class Allocator = allocator<ranges::range_value_t<R>>>
                                     basic_string(from_range_t, R&&, Allocator = Allocator())
                                     -> basic_string<ranges::range_value_t<R>, char_traits<ranges::range_value_t<R>>,
                                             Allocator>;
template<class charT,
         class traits,
         class Allocator = allocator<charT>>
explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
-> basic_string<charT, traits, Allocator>;
template<class charT,
         class traits,
         class Allocator = allocator<charT>>
basic_string(basic_string_view<charT, traits>,
             typename see below::size_type, typename see below::size_type,
             const Allocator& = Allocator())
-> basic_string<charT, traits, Allocator>;
//  A size_type parameter type in a basic_string deduction guide refers to the size_type member type of the type deduced by the deduction guide.
//  The types iterator and const_iterator meet the constexpr iterator requirements (25.3.1).
// 23.4.3.2 General requirements [string.require]
//  If any operation would cause size() to exceed max_size(), that operation throws an exception object of type length_error.
//  If any member function or operator of basic_string throws an exception, that function or operator has no other effect on the basic_string object.
//  In every specialization basic_string<charT, traits, Allocator>, the type allocator_traits<All- ocator>::value_type shall name the same type as charT. Every object of type basic_string<charT, as an argument.213
// — Calling non-const member functions, except operator[], at, data, front, back, begin, rbegin, end, and rend. traits, Allocator> uses an object of type Allocator to allocate and free storage for the contained charT objects as needed. The Allocator object used is obtained as described in 24.2.2.1. In every spe- cialization basic_string<charT, traits, Allocator>, the type traits shall meet the character traits requirements (23.2).
// [Note 1: Every specialization basic_string<charT, traits, Allocator> is an allocator-aware container, but does not use the allocator’s construct and destroy member functions (24.2.2.1).
// [Note 2: The program is ill-formed if traits::char_type is not the same type as charT.
//  References, pointers, and iterators referring to the elements of a basic_string sequence may be invalidated by the following uses of that basic_string object:
// — Passing as an argument to any standard library function taking a reference to non-const basic_string
// 23.4.3.3 Constructors and assignment operators [string.cons]
constexpr explicit basic_string(const Allocator& a) noexcept;
// Postconditions: size() is equal to 0. constexpr basic_string(const basic_string& str);
constexpr basic_string(basic_string&& str) noexcept;
// Effects: Constructs an object whose value is that of str prior to this call. Remarks: In the second form, str is left in a valid but unspecified state.
constexpr basic_string(const basic_string& str, size_type pos,
                       const Allocator& a = Allocator());
constexpr basic_string(const basic_string& str, size_type pos, size_type n,
                       const Allocator& a = Allocator());
// Effects: Let n be npos for the first overload. Equivalent to: basic_string(basic_string_view<charT, traits>(str).substr(pos, n), a)
template<class T>
constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
// Constraints: is_convertible_v<const T&, basic_string_view<charT, traits>> is true. Effects: Creates a variable, sv, as if by basic_string_view<charT, traits> sv = t; and then behaves the same as:
basic_string(sv.substr(pos, n), a);
template<class T>
constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
// Constraints:— is_convertible_v<const T&, basic_string_view<charT, traits>> is true and
// — is_convertible_v<const T&, const charT*> is false.
// Effects: Creates a variable, sv, as if by basic_string_view<charT, traits> sv = t; and then behaves the same as basic_string(sv.data(), sv.size(), a).
constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
// Preconditions: [s, s + n) is a valid range.
// Effects: Constructs an object whose initial value is the range [s, s + n).
// Postconditions: size() is equal to n, and traits::compare(data(), s, n) is equal to 0.
constexpr basic_string(const charT* s, const Allocator& a = Allocator());
// Constraints: Allocator is a type that qualifies as an allocator (24.2.2.1). [Note 1: This affects class template argument deduction. —end note]
// Effects: Equivalent to: basic_string(s, traits::length(s), a).
// Constraints: Allocator is a type that qualifies as an allocator (24.2.2.1).
constexpr basic_string& operator=(const basic_string& str);
constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
// Constraints: Allocator is a type that qualifies as an allocator (24.2.2.1). [Note 2: This affects class template argument deduction.
// Effects: Constructs an object whose value consists of n copies of c.
template<class InputIterator>
constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
// Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
// Effects: Constructs a string from the values in the range [begin, end), as specified in 24.2.4.
template<container-compatible-range<charT> R>
constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
// Effects: Constructs a string from the values in the range rg, as specified in 24.2.4. constexpr basic_string(initializer_list<charT> il, const Allocator& a = Allocator());
// Effects: Equivalent to basic_string(il.begin(), il.end(), a).
constexpr basic_string(const basic_string& str, const Allocator& alloc);
constexpr basic_string(basic_string&& str, const Allocator& alloc);
// Effects: Constructs an object whose value is that of str prior to this call. The stored allocator is constructed from alloc. In the second form, str is left in a valid but unspecified state.
// Throws: The second form throws nothing if alloc == str.get_allocator().
template<class InputIterator,
         class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
basic_string(InputIterator, InputIterator, Allocator = Allocator())
-> basic_string<typename iterator_traits<InputIterator>::value_type,
    char_traits<typename iterator_traits<InputIterator>::value_type>,
    Allocator>;
// Constraints: InputIterator is a type that qualifies as an input iterator, and Allocator is a type that qualifies as an allocator (24.2.2.1).
template<class charT,
         class traits,
         class Allocator = allocator<charT>>
explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
-> basic_string<charT, traits, Allocator>;
template<class charT,
         class traits,
         class Allocator = allocator<charT>>
basic_string(basic_string_view<charT, traits>,
             typename see below::size_type, typename see below::size_type,
             const Allocator& = Allocator())
-> basic_string<charT, traits, Allocator>;
// Effects: If *this and str are the same object, has no effect. Otherwise, replaces the value of *this with a copy of str.
// Returns: *this.
constexpr basic_string& operator=(basic_string&& str)
noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
         allocator_traits<Allocator>::is_always_equal::value);
// Effects: Move assigns as a sequence container (24.2), except that iterators, pointers and references may be invalidated.
// Returns: *this. template<class T>
constexpr basic_string& operator=(const T& t);
// Constraints:— is_convertible_v<const T&, basic_string_view<charT, traits>> is true and
// — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to: basic_string_view<charT, traits> sv = t;
return assign(sv);
constexpr basic_string& operator=(const charT* s);
// Effects: Equivalent to: return *this = basic_string_view<charT, traits>(s);
constexpr basic_string& operator=(charT c);
// Effects: Equivalent to:
return *this = basic_string_view<charT, traits>(addressof(c), 1);
constexpr basic_string& operator=(initializer_list<charT> il);
// Effects: Equivalent to:
return *this = basic_string_view<charT, traits>(il.begin(), il.size());
// 23.4.3.4 Iterator support [string.iterators]
constexpr iterator       begin() noexcept;
constexpr const_iterator begin() const noexcept;
constexpr const_iterator cbegin() const noexcept;
// Returns: An iterator referring to the first character in the string.
constexpr iterator       end() noexcept;
constexpr const_iterator end() const noexcept;
constexpr const_iterator cend() const noexcept;
// Returns: An iterator which is the past-the-end value.
constexpr reverse_iterator       rbegin() noexcept;
constexpr const_reverse_iterator rbegin() const noexcept;
constexpr const_reverse_iterator crbegin() const noexcept;
// Returns: An iterator which is semantically equivalent to reverse_iterator(end()).
constexpr reverse_iterator       rend() noexcept;
constexpr const_reverse_iterator rend() const noexcept;
constexpr const_reverse_iterator crend() const noexcept;
// Returns: An iterator which is semantically equivalent to reverse_iterator(begin()).
// 23.4.3.5 Capacity [string.capacity]
constexpr size_type size() const noexcept;
constexpr size_type length() const noexcept;
// Returns: A count of the number of char-like objects currently in the string. Complexity: Constant time.
constexpr size_type max_size() const noexcept;
// Returns: The largest possible number of char-like objects that can be stored in a basic_string. Complexity: Constant time.
constexpr void resize(size_type n, charT c);
// Effects: Alters the value of *this as follows:
// — If n <= size(), erases the last size() - n elements. — If n > size(), appends n - size() copies of c.
constexpr void resize(size_type n);
// Effects: Equivalent to resize(n, charT()).
template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
// Let — o = size() before the call to resize_and_overwrite.
// — k be min(o, n).
// — p be a charT*, such that the range [p, p + n] is valid and this->compare(0, k, p, k) == 0 is true before the call. The values in the range [p + k, p + n] may be indeterminate (6.7.4).
// — OP be the expression std::move(op)(p, n).
// — r = OP.
// Mandates: OP has an integer-like type (25.3.4.4). Preconditions:
// — OP does not throw an exception or modify p or n.
// — r ≥ 0.
// — r ≤ n.
// — After evaluating OP there are no indeterminate values in the range [p, p + r).
// Effects: Evaluates OP, replaces the contents of *this with [p,p + r), and invalidates all pointers and references to the range [p, p + n].
// Recommended practice: Implementations should avoid unnecessary copies and allocations by, for example, making p a pointer into internal storage and by restoring *(p + r) to charT() after evaluating OP.
constexpr size_type capacity() const noexcept;
// Returns: The size of the allocated storage in the string. Complexity: Constant time.
constexpr void reserve(size_type res_arg);
// Effects: A directive that informs a basic_string of a planned change in size, so that the storage allocation can be managed accordingly. After reserve(), capacity() is greater or equal to the argument of reserve if reallocation happens; and equal to the previous value of capacity() otherwise. Reallocation happens at this point if and only if the current capacity is less than the argument of reserve().
// Throws: length_error if res_arg > max_size() or any exceptions thrown by allocator_traits <Allocator>::allocate.
constexpr void shrink_to_fit();
// Effects: shrink_to_fit is a non-binding request to reduce capacity() to size().
// [Note 1: The request is non-binding to allow latitude for implementation-specific optimizations.
// It does not increase capacity(), but may reduce capacity() by causing reallocation.
// Complexity: If the size is not equal to the old capacity, linear in the size of the sequence; otherwise constant.
// Remarks: Reallocation invalidates all the references, pointers, and iterators referring to the elements in the sequence, as well as the past-the-end iterator.
// [Note 2: If no reallocation happens, they remain valid. —end note] constexpr void clear() noexcept;
// Effects: Equivalent to: erase(begin(), end());
[[nodiscard]] constexpr bool empty() const noexcept;
// Effects: Equivalent to: return size() == 0;
// 23.4.3.6 Element access [string.access]
constexpr const_reference operator[](size_type pos) const;
constexpr reference       operator[](size_type pos);
// Preconditions: pos <= size().
// Returns: *(begin() + pos) if pos < size(). Otherwise, returns a reference to an object of type charT with value charT(), where modifying the object to any value other than charT() leads to undefined behavior.
// Throws: Nothing. Complexity: Constant time.
constexpr const_reference at(size_type pos) const;
constexpr reference       at(size_type pos);
// Returns: operator[](pos).
// Throws: out_of_range if pos >= size().
constexpr const charT& front() const;
constexpr charT& front();
// Preconditions: !empty().
// Effects: Equivalent to: return operator[](0);
constexpr const charT& back() const;
constexpr charT& back();
// Preconditions: !empty().
// Effects: Equivalent to: return operator[](size() - 1);
// 23.4.3.7 Modifiers [string.modifiers]
// 23.4.3.7.1 basic_string::operator+= [string.op.append]
constexpr basic_string& operator+=(const basic_string& str);
// Effects: Equivalent to:
return append(str);
template<class T>
constexpr basic_string& operator+=(const T& t);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
basic_string_view<charT, traits> sv = t;
return append(sv);
constexpr basic_string& operator+=(const charT* s);
// Effects: Equivalent to:
return append(s);
constexpr basic_string& operator+=(charT c);
// Effects: Equivalent to:
return append(size_type{1}, c);
constexpr basic_string& operator+=(initializer_list<charT> il);
// Effects: Equivalent to: return append(il);
// 23.4.3.7.2 basic_string::append [string.append]
constexpr basic_string& append(const basic_string& str);
// Effects: Equivalent to:
return append(str.data(), str.size());
constexpr basic_string& append(const basic_string& str, size_type pos, size_type n = npos);
// Effects: Equivalent to:
return append(basic_string_view<charT, traits>(str).substr(pos, n));
template<class T>
constexpr basic_string& append(const T& t);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and
// — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
basic_string_view<charT, traits> sv = t;
return append(sv.data(), sv.size());
template<class T>
constexpr basic_string& append(const T& t, size_type pos, size_type n = npos);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and
// — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
basic_string_view<charT, traits> sv = t;
return append(sv.substr(pos, n));
constexpr basic_string& append(const charT* s, size_type n);
// Preconditions: [s, s + n) is a valid range.
// Effects: Appends a copy of the range [s, s + n) to the string. Returns: *this.
constexpr basic_string& append(const charT* s);
// Effects: Equivalent to:
return append(s, traits::length(s));
constexpr basic_string& append(size_type n, charT c);
// Effects: Appends n copies of c to the string. Returns: *this.
template<class InputIterator>
constexpr basic_string& append(InputIterator first, InputIterator last);
Constraints:
InputIterator is a type that qualifies as an input iterator (24.2.2.1).
// Effects: Equivalent to:
return append(basic_string(first, last, get_allocator()));
template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
// Effects: Equivalent to:
return append(basic_string(from_range, std::forward<R>(rg), get_- allocator()));
constexpr basic_string& append(initializer_list<charT> il);
// Effects: Equivalent to:
return append(il.begin(), il.size());
constexpr void push_back(charT c);
// Effects: Equivalent to append(size_type{1}, c).
// 23.4.3.7.3 basic_string::assign [string.assign]
constexpr basic_string& assign(const basic_string& str);
// Effects: Equivalent to:
return *this = str;
constexpr basic_string& assign(basic_string&& str)
noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
         allocator_traits<Allocator>::is_always_equal::value);
// Effects: Equivalent to:
return *this = std::move(str);
constexpr basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);
// Effects: Equivalent to:
return assign(basic_string_view<charT, traits>(str).substr(pos, n));
template<class T>
constexpr basic_string& assign(const T& t);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
basic_string_view<charT, traits> sv = t;
return assign(sv.data(), sv.size());
template<class T>
constexpr basic_string& assign(const T& t, size_type pos, size_type n = npos);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
basic_string_view<charT, traits> sv = t;
return assign(sv.substr(pos, n));
constexpr basic_string& assign(const charT* s, size_type n);
// Preconditions: [s, s + n) is a valid range.
// Effects: Replaces the string controlled by *this with a copy of the range [s, s + n). Returns: *this.
constexpr basic_string& assign(const charT* s);
// Effects: Equivalent to:
return assign(s, traits::length(s));
constexpr basic_string& assign(initializer_list<charT> il);
// Effects: Equivalent to:
return assign(il.begin(), il.size());
constexpr basic_string& assign(size_type n, charT c);
// Effects: Equivalent to:
clear();
resize(n, c);
return *this;
template<class InputIterator>
constexpr basic_string& assign(InputIterator first, InputIterator last);
// Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
// Effects: Equivalent to:
return assign(basic_string(first, last, get_allocator()));
template<container-compatible-range<charT> R>
constexpr basic_string& assign_range(R&& rg);
// Effects: Equivalent to:
return assign(basic_string(from_range, std::forward<R>(rg), get_- allocator()));
// 23.4.3.7.4 basic_string::insert [string.insert]
constexpr basic_string& insert(size_type pos, const basic_string& str);
// Effects: Equivalent to:
return insert(pos, str.data(), str.size());
constexpr basic_string& insert(size_type pos1, const basic_string& str,
                               size_type pos2, size_type n = npos);
// Effects: Equivalent to:
return insert(pos1, basic_string_view<charT, traits>(str), pos2, n);
template<class T>
constexpr basic_string& insert(size_type pos, const T& t);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to: basic_string_view<charT, traits> sv = t;
return insert(pos, sv.data(), sv.size());
template<class T>
constexpr basic_string& insert(size_type pos1, const T& t,
                               size_type pos2, size_type n = npos);
// Constraints:— is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to: basic_string_view<charT, traits> sv = t;
return insert(pos1, sv.substr(pos2, n));
constexpr basic_string& insert(size_type pos, const charT* s, size_type n);
// Preconditions: [s, s + n) is a valid range.
// Effects: Inserts a copy of the range [s, s + n) immediately before the character at position pos if pos < size(), or otherwise at the end of the string. Returns: *this.
// Throws: — out_of_range if pos > size(),
// — length_error if n > max_size() - size(), or
// — any exceptions thrown by allocator_traits<Allocator>::allocate.
constexpr basic_string& insert(size_type pos, const charT* s);
// Effects: Equivalent to: return insert(pos, s, traits::length(s));
constexpr basic_string& insert(size_type pos, size_type n, charT c);
// Effects: Inserts n copies of c before the character at position pos if pos < size(), or otherwise at the end of the string.
// Returns: *this
// Throws: — out_of_range if pos > size(),
// — length_error if n > max_size() - size(), or
// — any exceptions thrown by allocator_traits<Allocator>::allocate.
constexpr iterator insert(const_iterator p, charT c);
// Preconditions: p is a valid iterator on *this.
// Effects: Inserts a copy of c at the position p.
// Returns: An iterator which refers to the inserted character.
constexpr iterator insert(const_iterator p, size_type n, charT c);
// Preconditions: p is a valid iterator on *this.
// Effects: Inserts n copies of c at the position p.
// Returns: An iterator which refers to the first inserted character, or p if n == 0.
template<class InputIterator>
constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
// Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
// Preconditions: p is a valid iterator on *this.
// Effects: Equivalent to insert(p - begin(), basic_string(first, last, get_allocator())). Returns: An iterator which refers to the first inserted character, or p if first == last.
template<container-compatible-range<charT> R>
constexpr iterator insert_range(const_iterator p, R&& rg);
// Preconditions: p is a valid iterator on *this.
// Effects: Equivalent to insert(p - begin(), basic_string(from_range, std::forward<R>(rg), get_allocator())).
// Returns: An iterator which refers to the first inserted character, or p if rg is empty.
constexpr iterator insert(const_iterator p, initializer_list<charT> il);
// Effects: Equivalent to: return insert(p, il.begin(), il.end());
// 23.4.3.7.5 basic_string::erase
constexpr basic_string& erase(size_type pos = 0, size_type n = npos);
// Effects: Determines the effective length xlen of the string to be removed as the smaller of n and size() - pos. Removes the characters in the range [begin() + pos, begin() + pos + xlen).
// Returns: *this.
// Throws: out_of_range if pos > size().
constexpr iterator erase(const_iterator p);
// Preconditions: p is a valid dereferenceable iterator on *this. Effects: Removes the character referred to by p.
// Returns: An iterator which points to the element immediately following p prior to the element being erased. If no such element exists, end() is returned.
// Throws: Nothing.
constexpr iterator erase(const_iterator first, const_iterator last);
// Preconditions: first and last are valid iterators on *this. [first, last) is a valid range. Effects: Removes the characters in the range [first, last).
// Returns: An iterator which points to the element pointed to by last prior to the other elements being erased. If no such element exists, end() is returned.
// Throws: Nothing.
constexpr void pop_back();
// Preconditions: !empty().
// Effects: Equivalent to erase(end() - 1).
// Throws: Nothing.
// 23.4.3.7.6 basic_string::replace [string.replace]
constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
// Effects: Equivalent to:
return replace(pos1, n1, str.data(), str.size());
constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
                                size_type pos2, size_type n2 = npos);
// Effects: Equivalent to:
return replace(pos1, n1, basic_string_view<charT, traits>(str).substr(pos2, n2));
template<class T>
constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to: basic_string_view<charT, traits> sv = t;
return replace(pos1, n1, sv.data(), sv.size());
template<class T>
constexpr basic_string& replace(size_type pos1, size_type n1, const T& t,
                                size_type pos2, size_type n2 = npos);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
basic_string_view<charT, traits> sv = t;
return replace(pos1, n1, sv.substr(pos2, n2));
constexpr basic_string& replace(size_type pos1, size_type n1, const charT* s, size_type n2);
// Preconditions: [s, s + n2) is a valid range.
// Effects: Determines the effective length xlen of the string to be removed as the smaller of n1 and size() - pos1. If size() - xlen >= max_size() - n2 throws length_error. Otherwise, the function replaces the characters in the range [begin() + pos1, begin() + pos1 + xlen) with a copy of the range [s, s + n2). Returns: *this. Throws:
// — out_of_range if pos1 > size(),
// — length_error if the length of the resulting string would exceed max_size(), or — any exceptions thrown by allocator_traits<Allocator>::allocate.
constexpr basic_string& replace(size_type pos, size_type n, const charT* s);
// Effects: Equivalent to: return replace(pos, n, s, traits::length(s)); constexpr basic_string& replace(size_type pos1, size_type n1, size_type n2, charT c);
// Effects: Determines the effective length xlen of the string to be removed as the smaller of n1 and size() - pos1. If size() - xlen >= max_size() - n2 throws length_error. Otherwise, the function replaces the characters in the range [begin() + pos1, begin() + pos1 + xlen) with n2 copies of c.
// Returns: *this. Throws:
// — out_of_range if pos1 > size(),
// — length_error if the length of the resulting string would exceedmax_size(), or — any exceptions thrown by allocator_traits<Allocator>::allocate.
constexpr basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
// Effects: Equivalent to: return replace(i1, i2, basic_string_view<charT, traits>(str)); template<class T>
constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Preconditions: [begin(), i1) and [i1, i2) are valid ranges.
// Effects: Equivalent to:
basic_string_view<charT, traits> sv = t;
return replace(i1 - begin(), i2 - i1, sv.data(), sv.size());
constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
// Effects: Equivalent to: return replace(i1, i2, basic_string_view<charT, traits>(s, n)); constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
// Effects: Equivalent to: return replace(i1, i2, basic_string_view<charT, traits>(s));
constexpr basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);
// Preconditions: [begin(), i1) and [i1, i2) are valid ranges.
// Effects: Equivalent to: return replace(i1 - begin(), i2 - i1, n, c);
template<class InputIterator>
constexpr basic_string& replace(const_iterator i1, const_iterator i2,
                                InputIterator j1, InputIterator j2);
// Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
// Effects: Equivalent to: return replace(i1, i2, basic_string(j1, j2, get_allocator()));
template<container-compatible-range<charT> R>
constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg);
// Effects: Equivalent to:
return replace(i1, i2, basic_string(from_range, std::forward<R>(rg), get_allocator()));
constexpr basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il);
// Effects: Equivalent to: return replace(i1, i2, il.begin(), il.size());
// 23.4.3.7.7 basic_string::copy [string.copy]
constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
// Effects: Equivalent to:
return basic_string_view<charT, traits>(*this).copy(s, n, pos);
// [Note 1: This does not terminate s with a null object.
// 23.4.3.7.8 basic_string::swap [string.swap]
constexpr void swap(basic_string& s)
noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
         allocator_traits<Allocator>::is_always_equal::value);
// Preconditions: allocator_traits<Allocator>::propagate_on_container_swap::value is true or get_allocator() == s.get_allocator().
// — Each member function of the form
constexpr size_type F(const basic_string& str, size_type pos) const noexcept;
// has effects equivalent to:
return F (basic_string_view<charT, traits>(str), pos);
// — Each member function of the form
constexpr size_type F(const charT* s, size_type pos) const;
// has effects equivalent to:
return F (basic_string_view<charT, traits>(s), pos);
// — Each member function of the form
constexpr size_type F(const charT* s, size_type pos, size_type n) const;
// has effects equivalent to: return F (basic_string_view<charT, traits>(s, n), pos);
// — Each member function of the form
constexpr size_type F(charT c, size_type pos) const noexcept;
has effects equivalent to:
return F(basic_string_view<charT, traits>(addressof(c), 1), pos);
template<class T>
constexpr size_type find(const T& t, size_type pos = 0) const noexcept(see below);
template<class T>
constexpr size_type rfind(const T& t, size_type pos = npos) const noexcept(see_below);
template<class T>
constexpr size_type find_first_of(const T& t, size_type pos = 0) const noexcept(see_below);
template<class T>
constexpr size_type find_last_of(const T& t, size_type pos = npos) const noexcept(see_below);
template<class T>
constexpr size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept(see_below);
// Postconditions: *this contains the same sequence of characters that was in s, s contains the same sequence of characters that was in *this.
//  Let F be one of find, rfind, find_first_of, find_last_of, find_first_not_of, and find_last_not_of.
// Throws: Nothing. Complexity: Constant time.
// 23.4.3.8 String operations  [string.ops]
// 23.4.3.8.1 Accessors [string.accessors]
constexpr const charT* c_str() const noexcept;
constexpr const charT* data() const noexcept;
// Returns: A pointer p such that p + i == addressof(operator[](i)) for each i in [0, size()]. Complexity: Constant time.
// Remarks: The program shall not modify any of the values stored in the character array; otherwise, the behavior is undefined.
constexpr charT* data() noexcept;
// Returns: A pointer p such that p + i == addressof(operator[](i)) for each i in [0, size()]. Complexity: Constant time.
// Remarks: The program shall not modify the value stored at p + size() to any value other than charT(); otherwise, the behavior is undefined.
constexpr operator basic_string_view<charT, traits>() const noexcept;
// Effects: Equivalent to: return basic_string_view<charT, traits>(data(), size()); constexpr allocator_type get_allocator() const noexcept;
// Returns: A copy of the Allocator object used to construct the string or, if that allocator has been replaced, a copy of the most recent replacement.
// 23.4.3.8.2 Searching [string.find]
template<class T>
constexpr size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept(see below);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Let G be the name of the function. Equivalent to: basic_string_view<charT, traits> s = *this, sv = t;
return s.G(sv, pos);
// Remarks: The exception specification is equivalent to is_nothrow_convertible_v<const T&, basic_- string_view<charT, traits>>.
// 23.4.3.8.3 basic_string::substr [string.substr]
constexpr basic_string substr(size_type pos = 0, size_type n = npos) const;
// Effects: Determines the effective length rlen of the string to copy as the smaller of n and size() - pos.
// Returns: basic_string(data()+pos, rlen). Throws: out_of_range if pos > size().
// 23.4.3.8.4 basic_string::compare template<class T> [string.compare]
constexpr int compare(const T& t) const noexcept(see_below);
// Constraints:— is_convertible_v<const T&, basic_string_view<charT, traits>> is true and
// — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to: return basic_string_view<charT, traits>(*this).compare(t);
// Remarks: The exception specification is equivalent to is_nothrow_convertible_v<const T&, basic_- string_view<charT, traits>>.
template<class T>
constexpr int compare(size_type pos1, size_type n1, const T& t) const;
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
return basic_string_view<charT, traits>(*this).substr(pos1, n1).compare(t);
template<class T>
constexpr int compare(size_type pos1, size_type n1, const T& t,
                      size_type pos2, size_type n2 = npos) const;
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
basic_string_view<charT, traits> s = *this, sv = t;
return s.substr(pos1, n1).compare(sv.substr(pos2, n2));
constexpr int compare(const basic_string& str) const noexcept;
// Effects: Equivalent to: return compare(basic_string_view<charT, traits>(str)); constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
// Effects: Equivalent to: return compare(pos1, n1, basic_string_view<charT, traits>(str));
operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
// Effects: Equivalent to:
basic_string<charT, traits, Allocator> r = lhs;
r.append(rhs);
return r;
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs,
          const basic_string<charT, traits, Allocator>& rhs);
constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
                      size_type pos2, size_type n2 = npos) const;
// Effects: Equivalent to:
return compare(pos1, n1, basic_string_view<charT, traits>(str), pos2, n2);
constexpr int compare(const charT* s) const;
// Effects: Equivalent to: return compare(basic_string_view<charT, traits>(s)); constexpr int compare(size_type pos, size_type n1, const charT* s) const;
// Effects: Equivalent to: return compare(pos, n1, basic_string_view<charT, traits>(s));
constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
// Effects: Equivalent to: return compare(pos, n1, basic_string_view<charT, traits>(s, n2));
// 23.4.3.8.5 basic_string::starts_with [string.starts.with]
constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
constexpr bool starts_with(charT x) const noexcept;
constexpr bool starts_with(const charT* x) const;
// Effects: Equivalent to:
return basic_string_view<charT, traits>(data(), size()).starts_with(x);
// 23.4.3.8.6 basic_string::ends_with [string.ends.with]
constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
constexpr bool ends_with(charT x) const noexcept;
constexpr bool ends_with(const charT* x) const;
// Effects: Equivalent to:
return basic_string_view<charT, traits>(data(), size()).ends_with(x);
// 23.4.3.8.7 basic_string::contains [string.contains]
constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
constexpr bool contains(charT x) const noexcept;
constexpr bool contains(const charT* x) const;
// Effects: Equivalent to:
return basic_string_view<charT, traits>(data(), size()).contains(x);
// 23.4.4 Non-member functions  [string.nonmembers]
// 23.4.4.1 operator+ [string.op.plus]
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs,
          const basic_string<charT, traits, Allocator>& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs, const charT* rhs);
// Effects: Equivalent to: lhs.append(rhs);
return std::move(lhs);
operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
// Effects: Equivalent to: rhs.insert(0, lhs);
return std::move(rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs,
          basic_string<charT, traits, Allocator>&& rhs);
// Effects: Equivalent to: lhs.append(rhs);
return std::move(lhs);
// except that both lhs and rhs are left in valid but unspecified states.
// [Note 1: If lhs and rhs have equal allocators, the implementation can move from either.
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs,
          basic_string<charT, traits, Allocator>&& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs);
// Effects: Equivalent to:
basic_string<charT, traits, Allocator> r = rhs;
r.insert(0, lhs);
return r;
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(charT lhs, const basic_string<charT, traits, Allocator>& rhs);
// Effects: Equivalent to:
basic_string<charT, traits, Allocator> r = rhs;
r.insert(r.begin(), lhs);
return r;
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(charT lhs, basic_string<charT, traits, Allocator>&& rhs);
// Effects: Equivalent to: rhs.insert(rhs.begin(), lhs);
return std::move(rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs);
// Effects: Equivalent to:
basic_string<charT, traits, Allocator> r = lhs;
r.push_back(rhs);
return r;
constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
// Effects: Let op be the operator. Equivalent to:
return basic_string_view<charT, traits>(lhs) op basic_string_view<charT, traits>(rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs, charT rhs);
// Effects: Equivalent to: lhs.push_back(rhs);
return std::move(lhs);
// 23.4.4.2 Non-member comparison operator functions [string.special]
template<class charT, class traits, class Allocator>
constexpr bool
operator==(const basic_string<charT, traits, Allocator>& lhs,
           const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
                          const charT* rhs);
template<class charT, class traits, class Allocator>
constexpr see_below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
                                const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
// 23.4.4.3 swap [string.io]
template<class charT, class traits, class Allocator>
constexpr void
swap(basic_string<charT, traits, Allocator>& lhs,
     basic_string<charT, traits, Allocator>& rhs)
noexcept(noexcept(lhs.swap(rhs)));
// Effects: Equivalent to lhs.swap(rhs).
// 23.4.4.4 Inserters and extractors [string.cmp]
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
// Effects: Behaves as a formatted input function (31.7.4.3.1). After constructing a sentry object, if the sentry object returns true when converted to a value of type bool, calls str.erase() and then extracts characters from is and appends them to str as if by calling str.append(1, c). If is.width() is greater than zero, the maximum number n of characters appended is is.width(); otherwise n is str.max_size(). Characters are extracted and appended until any of the following occurs:
// — n characters are stored;
// — end-of-file occurs on the input sequence;
// — isspace(c, is.getloc()) is true for the next available input character c.
// After the last character (if any) is extracted, is.width(0) is called and the sentry object is destroyed. If the function extracts no characters, it calls is.setstate(ios_base::failbit), which may throw ios_base::failure (31.5.4.4).
// Returns: is.
template<class charT, class traits, class Allocator>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
           const basic_string<charT, traits, Allocator>& str);
// Effects: Equivalent to: return os << basic_string_view<charT, traits>(str);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
        basic_string<charT, traits, Allocator>& str,
        charT delim);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>&& is,
        basic_string<charT, traits, Allocator>& str,
        charT delim);
// Effects: Behaves as an unformatted input function (31.7.4.4), except that it does not affect the value returned by subsequent calls to basic_istream<>::gcount(). After constructing a sentry object, if the sentry object returns true when converted to a value of type bool, calls str.erase() and then extracts characters from is and appends them to str as if by calling str.append(1, c) until any of the following occurs:
// — end-of-file occurs on the input sequence (in which case, the getline function calls is.setstate( ios_base::eofbit)).
// — traits::eq(c, delim) for the next available input character c (in which case, c is extracted but not appended) (31.5.4.4)
// — str.max_size() characters are stored (in which case, the function calls is.setstate(ios_- base::failbit)) (31.5.4.4)
// The conditions are tested in the order shown. In any case, after the last character is extracted, the sentry object is destroyed. If the function extracts no characters, it calls is.setstate(ios_base::failbit) which may throw ios_base::failure (31.5.4.4).
// Returns: is.
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
        basic_string<charT, traits, Allocator>& str);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>&& is,
        basic_string<charT, traits, Allocator>& str);
// Returns: getline(is, str, is.widen(’\n’)).
// 23.4.4.5 Erasure [string.erasure]
template<class charT, class traits, class Allocator, class U>
constexpr typename basic_string<charT, traits, Allocator>::size_type
erase(basic_string<charT, traits, Allocator>& c, const U& value);
// Effects: Equivalent to:
auto it = remove(c.begin(), c.end(), value);
auto r = distance(it, c.end());
c.erase(it, c.end());
return r;
template<class charT, class traits, class Allocator, class Predicate>
constexpr typename basic_string<charT, traits, Allocator>::size_type
erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred);
// Effects: Equivalent to:
auto it = remove_if(c.begin(), c.end(), pred);
auto r = distance(it, c.end());
c.erase(it, c.end());
return r;
// Returns: Each function returns a string object holding the character representation of the value of its argument that would be generated by calling sprintf(buf, fmt, val) with a format specifier of "%d", "%u", "%ld", "%lu", "%lld", "%llu", "%f", "%f", or "%Lf", respectively, where buf designates an internal character buffer of sufficient size.
// 23.4.5 Numeric conversions [string.conversions]
int stoi(const string& str, size_t* idx = nullptr, int base = 10);
long stol(const string& str, size_t* idx = nullptr, int base = 10);
unsigned long stoul(const string& str, size_t* idx = nullptr, int base = 10);
long long stoll(const string& str, size_t* idx = nullptr, int base = 10);
unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10);
// Effects: The first two functions call strtol(str.c_str(), ptr, base), and the last three functions call strtoul(str.c_str(), ptr, base), strtoll(str.c_str(), ptr, base), and strtoull(str.c_- str(), ptr, base), respectively. Each function returns the converted result, if any. The argument ptr designates a pointer to an object internal to the function that is used to determine what to store at *idx. If the function does not throw an exception and idx != nullptr, the function stores in *idx the index of the first unconverted element of str.
// Returns: The converted result.
// Throws: invalid_argument if strtol, strtoul, strtoll, or strtoull reports that no conversion can be performed. Throws out_of_range if strtol, strtoul, strtoll or strtoull sets errno to ERANGE, or if the converted value is outside the range of representable values for the return type.
float stof(const string& str, size_t* idx = nullptr);
double stod(const string& str, size_t* idx = nullptr);
long double stold(const string& str, size_t* idx = nullptr);
// Effects: These functions call strtof(str.c_str(), ptr), strtod(str.c_str(), ptr), and strtold( str.c_str(), ptr), respectively. Each function returns the converted result, if any. The argument ptr designates a pointer to an object internal to the function that is used to determine what to store at *idx. If the function does not throw an exception and idx != nullptr, the function stores in *idx the index of the first unconverted element of str.
// Returns: The converted result.
// Throws: invalid_argument if strtof, strtod, or strtold reports that no conversion can be performed. Throws out_of_range if strtof, strtod, or strtold sets errno to ERANGE or if the converted value is outside the range of representable values for the return type.
string to_string(int val);
string to_string(unsigned val);
string to_string(long val);
string to_string(unsigned long val);
string to_string(long long val);
string to_string(unsigned long long val);
string to_string(float val);
string to_string(double val);
string to_string(long double val);
int stoi(const wstring& str, size_t* idx = nullptr, int base = 10);
long stol(const wstring& str, size_t* idx = nullptr, int base = 10);
unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);
long long stoll(const wstring& str, size_t* idx = nullptr, int base = 10);
unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);
// Effects: The first two functions call wcstol(str.c_str(), ptr, base), and the last three functions call wcstoul(str.c_str(), ptr, base), wcstoll(str.c_str(), ptr, base), and wcstoull(str.c_- str(), ptr, base), respectively. Each function returns the converted result, if any. The argument ptr designates a pointer to an object internal to the function that is used to determine what to store at *idx. If the function does not throw an exception and idx != nullptr, the function stores in *idx the index of the first unconverted element of str.
// Returns: The converted result.
// Throws: invalid_argument if wcstol, wcstoul, wcstoll, or wcstoull reports that no conversion can be performed. Throws out_of_range if the converted value is outside the range of representable values for the return type.
// Returns: Each function returns a wstring object holding the character representation of the value of its argument that would be generated by calling swprintf(buf, buffsz, fmt, val) with a format specifier of L"%d", L"%u", L"%ld", L"%lu", L"%lld", L"%llu", L"%f", L"%f", or L"%Lf", respectively, where buf designates an internal character buffer of sufficient size buffsz.
// If S is one of these string types, SV is the corresponding string view type, and s is an object of type S, then hash<S>()(s) == hash<SV>()(SV(s)).
float stof(const wstring& str, size_t* idx = nullptr);
double stod(const wstring& str, size_t* idx = nullptr);
long double stold(const wstring& str, size_t* idx = nullptr);
// Effects: These functions call wcstof(str.c_str(), ptr), wcstod(str.c_str(), ptr), and wcstold( str.c_str(), ptr), respectively. Each function returns the converted result, if any. The argument ptr designates a pointer to an object internal to the function that is used to determine what to store at *idx. If the function does not throw an exception and idx != nullptr, the function stores in *idx the index of the first unconverted element of str.
// Returns: The converted result.
// Throws: invalid_argument if wcstof, wcstod, or wcstold reports that no conversion can be performed.
// Throws out_of_range if wcstof, wcstod, or wcstold sets errno to ERANGE.
wstring to_wstring(int val);
wstring to_wstring(unsigned val);
wstring to_wstring(long val);
wstring to_wstring(unsigned long val);
wstring to_wstring(long long val);
wstring to_wstring(unsigned long long val);
wstring to_wstring(float val);
wstring to_wstring(double val);
wstring to_wstring(long double val);
// 23.4.6 Hash support [basic.string.hash]
template<> struct hash<string>;
template<> struct hash<u8string>;
template<> struct hash<u16string>;
template<> struct hash<u32string>;
template<> struct hash<wstring>;
template<> struct hash<pmr::string>;
template<> struct hash<pmr::u8string>;
template<> struct hash<pmr::u16string>;
template<> struct hash<pmr::u32string>;
template<> struct hash<pmr::wstring>;
// 23.4.7 Suffix for basic_string literals [basic.string.literals]
constexpr string operator""s(const char* str, size_t len);
// Returns: string{str, len}.
constexpr u8string operator""s(const char8_t* str, size_t len);
// Returns: u8string{str, len}.
constexpr u16string operator""s(const char16_t* str, size_t len);
// Returns: u16string{str, len}.
constexpr u32string operator""s(const char32_t* str, size_t len);
// Returns: u32string{str, len}.
constexpr wstring operator""s(const wchar_t* str, size_t len);
// Returns: wstring{str, len}.
// [Note 1: The same suffix s is used for chrono::duration literals denoting seconds but there is no conflict, since duration suffixes apply to numbers and string literal suffixes apply to character array literals.
int main() {
    cout  <<  n4910 << endl;
    return EXIT_SUCCESS;
}
```

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

```ubuntu:bash
$ clang++ p808.cpp -std=03 -o p808l -I. -Wall
In file included from p808.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 \
 ^
p808.cpp:19:110: error: use of undeclared identifier 'char8_t'; did you mean 'wchar_t'?
template<class charT> struct char_traits; template<> struct char_traits<char>; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
                                                                                                             ^~~~~~~
                                                                                                             wchar_t
p808.cpp:19:150: error: use of undeclared identifier 'char16_t'
template<class charT> struct char_traits; template<> struct char_traits<char>; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
                                                                                                                                                     ^
p808.cpp:19:191: error: use of undeclared identifier 'char32_t'
template<class charT> struct char_traits; template<> struct char_traits<char>; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
                                                                                                                                                                                              ^
p808.cpp:21:91: error: a space is required between consecutive right angle brackets (use '> >')
template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
                                                                                          ^~
                                                                                          > >
p808.cpp:24:7: error: unknown type name 'constexpr'
      constexpr basic_string<charT, traits, Allocator>
      ^
p808.cpp:24:17: error: reference to 'basic_string' is ambiguous
      constexpr basic_string<charT, traits, Allocator>
                ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:24:17: error: no variable template matches partial specialization
      constexpr basic_string<charT, traits, Allocator>
                ^
p808.cpp:24:55: error: expected ';' at end of declaration
      constexpr basic_string<charT, traits, Allocator>
                                                      ^
                                                      ;
p808.cpp:25:25: error: reference to 'basic_string' is ambiguous
        operator+(const basic_string<charT, traits, Allocator>& lhs,
                        ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:25:38: error: use of undeclared identifier 'charT'; did you mean 'char'?
        operator+(const basic_string<charT, traits, Allocator>& lhs,
                                     ^~~~~
                                     char
p808.cpp:25:45: error: use of undeclared identifier 'traits'
        operator+(const basic_string<charT, traits, Allocator>& lhs,
                                            ^
p808.cpp:26:25: error: reference to 'basic_string' is ambiguous
                  const basic_string<charT, traits, Allocator>& rhs);
                        ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:26:38: error: use of undeclared identifier 'charT'; did you mean 'char'?
                  const basic_string<charT, traits, Allocator>& rhs);
                                     ^~~~~
                                     char
p808.cpp:26:45: error: use of undeclared identifier 'traits'
                  const basic_string<charT, traits, Allocator>& rhs);
                                            ^
p808.cpp:25:9: error: C++ requires a type specifier for all declarations
        operator+(const basic_string<charT, traits, Allocator>& lhs,
        ^
p808.cpp:28:7: error: unknown type name 'constexpr'
      constexpr basic_string<charT, traits, Allocator>
      ^
p808.cpp:28:17: error: reference to 'basic_string' is ambiguous
      constexpr basic_string<charT, traits, Allocator>
                ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:28:17: error: no variable template matches partial specialization
      constexpr basic_string<charT, traits, Allocator>
                ^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
20 errors generated.
$ clang++ p808.cpp -std=2b -o p808l -I. -Wall
p808.cpp:24:17: error: reference to 'basic_string' is ambiguous
      constexpr basic_string<charT, traits, Allocator>
                ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:25:25: error: reference to 'basic_string' is ambiguous
        operator+(const basic_string<charT, traits, Allocator>& lhs,
                        ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:26:25: error: reference to 'basic_string' is ambiguous
                  const basic_string<charT, traits, Allocator>& rhs);
                        ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:28:17: error: reference to 'basic_string' is ambiguous
      constexpr basic_string<charT, traits, Allocator>
                ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:29:19: error: reference to 'basic_string' is ambiguous
        operator+(basic_string<charT, traits, Allocator>&& lhs,
                  ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:30:25: error: reference to 'basic_string' is ambiguous
                  const basic_string<charT, traits, Allocator>& rhs);
                        ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:32:17: error: reference to 'basic_string' is ambiguous
      constexpr basic_string<charT, traits, Allocator>
                ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:33:25: error: reference to 'basic_string' is ambiguous
        operator+(const basic_string<charT, traits, Allocator>& lhs,
                        ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:34:19: error: reference to 'basic_string' is ambiguous
                  basic_string<charT, traits, Allocator>&& rhs);
                  ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:36:13: error: reference to 'basic_string' is ambiguous
  constexpr basic_string<charT, traits, Allocator>
            ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:37:15: error: reference to 'basic_string' is ambiguous
    operator+(basic_string<charT, traits, Allocator>&& lhs,
              ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:38:15: error: reference to 'basic_string' is ambiguous
              basic_string<charT, traits, Allocator>&& rhs);
              ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:40:13: error: reference to 'basic_string' is ambiguous
  constexpr basic_string<charT, traits, Allocator>
            ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:42:21: error: reference to 'basic_string' is ambiguous
              const basic_string<charT, traits, Allocator>& rhs);
                    ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:44:13: error: reference to 'basic_string' is ambiguous
  constexpr basic_string<charT, traits, Allocator>
            ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:46:15: error: reference to 'basic_string' is ambiguous
              basic_string<charT, traits, Allocator>&& rhs);
              ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:48:13: error: reference to 'basic_string' is ambiguous
  constexpr basic_string<charT, traits, Allocator>
            ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:50:21: error: reference to 'basic_string' is ambiguous
              const basic_string<charT, traits, Allocator>& rhs);
                    ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
p808.cpp:52:13: error: reference to 'basic_string' is ambiguous
  constexpr basic_string<charT, traits, Allocator>
            ^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
      class basic_string;
            ^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
    class basic_string
          ^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
20 errors generated.

$ g++ p808.cpp -std=03 -o p808g -I. -Wall
In file included from /usr/local/include/c++/12.1.0/atomic:38,
                 from N4910.h:11,
                 from p808.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 \
      |  ^~~~~
p808.cpp:24:7: warning: identifier 'constexpr' is a keyword in C++11 [-Wc++11-compat]
   24 |       constexpr basic_string<charT, traits, Allocator>
      |       ^~~~~~~~~
p808.cpp:74:67: warning: identifier 'noexcept' is a keyword in C++11 [-Wc++11-compat]
   74 |                const basic_string<charT, traits, Allocator>& rhs) noexcept;
      |                                                                   ^~~~~~~~
p808.cpp:126:43: warning: identifier 'nullptr' is a keyword in C++11 [-Wc++11-compat]
  126 | int stoi(const string& str, size_t* idx = nullptr, int base = 10);
      |                                           ^~~~~~~
p808.cpp:660:75: error: too many decimal points in number
  660 | Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
      |                                                                           ^~~~~~~~
p808.cpp:19:110: error: 'char8_t' was not declared in this scope; did you mean 'wchar_t'?
   19 | T> struct char_traits; template<> struct char_traits<char>; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
      |                                                                                           ^~~~~~~
      |                                                                                           wchar_t
p808.cpp:19:117: error: template argument 1 is invalid
   19 | ct char_traits; template<> struct char_traits<char>; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
      |                                                                                           ^

p808.cpp:19:150: error: 'char16_t' was not declared in this scope
   19 |  char_traits<char>; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
      |                                                                                           ^~~~~~~~

p808.cpp:19:158: error: template argument 1 is invalid
   19 | aits<char>; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
      |                                                                                           ^

p808.cpp:19:191: error: 'char32_t' was not declared in this scope
   19 | r_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
      |                                                                                           ^~~~~~~~

p808.cpp:19:199: error: template argument 1 is invalid
   19 | <char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
      |                                                                                           ^

p808.cpp:21:91: error: spurious '>>', use '>' to terminate a template argument list
   21 | template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
      |                                                                                           ^~
p808.cpp:22:13: error: template argument required for 'class basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:21:76: error: two or more data types in declaration of 'type name'
   21 | template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
      |                                                                            ^~~~~~~~~~~~~~~~~
p808.cpp:22:25: error: expected '>' before ';' token
   22 |       class basic_string;
      |                         ^
p808.cpp:22:25: error: expected unqualified-id before ';' token
p808.cpp:24:7: error: 'constexpr' does not name a type
   24 |       constexpr basic_string<charT, traits, Allocator>
      |       ^~~~~~~~~
p808.cpp:24:7: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:28:7: error: 'constexpr' does not name a type
   28 |       constexpr basic_string<charT, traits, Allocator>
      |       ^~~~~~~~~
p808.cpp:28:7: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:32:7: error: 'constexpr' does not name a type
   32 |       constexpr basic_string<charT, traits, Allocator>
      |       ^~~~~~~~~
p808.cpp:32:7: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:36:3: error: 'constexpr' does not name a type
   36 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:36:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:40:3: error: 'constexpr' does not name a type
   40 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:40:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:44:3: error: 'constexpr' does not name a type
   44 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:44:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:48:3: error: 'constexpr' does not name a type
   48 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:48:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:52:3: error: 'constexpr' does not name a type
   52 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:52:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:56:3: error: 'constexpr' does not name a type
   56 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:56:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:60:3: error: 'constexpr' does not name a type
   60 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:60:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:64:3: error: 'constexpr' does not name a type
   64 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:64:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:68:3: error: 'constexpr' does not name a type
   68 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:68:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:72:3: error: 'constexpr' does not name a type
   72 |   constexpr bool
      |   ^~~~~~~~~
p808.cpp:72:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:76:3: error: 'constexpr' does not name a type
   76 |   constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
      |   ^~~~~~~~~
p808.cpp:76:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:79:1: error: 'constexpr' does not name a type
   79 | constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
      | ^~~~~~~~~
p808.cpp:79:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:82:1: error: 'constexpr' does not name a type
   82 | constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      | ^~~~~~~~~
p808.cpp:82:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:85:3: error: 'constexpr' does not name a type
   85 |   constexpr void
      |   ^~~~~~~~~
p808.cpp:85:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:105:41: error: expected ',' or '...' before '&&' token
  105 |     getline(basic_istream<charT, traits>&& is,
      |                                         ^~
p808.cpp:114:41: error: expected ',' or '...' before '&&' token
  114 |     getline(basic_istream<charT, traits>&& is,
      |                                         ^~
p808.cpp:118:3: error: 'constexpr' does not name a type
  118 |   constexpr typename basic_string<charT, traits, Allocator>::size_type
      |   ^~~~~~~~~
p808.cpp:118:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:121:3: error: 'constexpr' does not name a type
  121 |   constexpr typename basic_string<charT, traits, Allocator>::size_type
      |   ^~~~~~~~~
p808.cpp:121:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:124:7: error: expected nested-name-specifier before 'string'
  124 | using string = basic_string<char>; using u8string = basic_string<char8_t>; using u16string = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
      |       ^~~~~~
p808.cpp:124:42: error: expected nested-name-specifier before 'u8string'
  124 | using string = basic_string<char>; using u8string = basic_string<char8_t>; using u16string = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
      |                                          ^~~~~~~~
p808.cpp:124:82: error: expected nested-name-specifier before 'u16string'
  124 | using string = basic_string<char>; using u8string = basic_string<char8_t>; using u16string = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
      |                                                                                  ^~~~~~~~~
p808.cpp:124:124: error: expected nested-name-specifier before 'u32string'
  124 | ; using u8string = basic_string<char8_t>; using u16string = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
      |                                                                                           ^~~~~~~~~

p808.cpp:124:166: error: expected nested-name-specifier before 'wstring'
  124 | using u16string = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
      |                                                                                           ^~~~~~~

p808.cpp:126:43: error: 'nullptr' was not declared in this scope
  126 | int stoi(const string& str, size_t* idx = nullptr, int base = 10);
      |                                           ^~~~~~~
p808.cpp:127:44: error: 'nullptr' was not declared in this scope
  127 | long stol(const string& str, size_t* idx = nullptr, int base = 10);
      |                                            ^~~~~~~
p808.cpp:128:54: error: 'nullptr' was not declared in this scope
  128 | unsigned long stoul(const string& str, size_t* idx = nullptr, int base = 10);
      |                                                      ^~~~~~~
p808.cpp:129:50: error: 'nullptr' was not declared in this scope
  129 | long long stoll(const string& str, size_t* idx = nullptr, int base = 10);
      |                                                  ^~~~~~~
p808.cpp:130:60: error: 'nullptr' was not declared in this scope
  130 | unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10); float stof(const string& str, size_t* idx = nullptr);
      |                                                            ^~~~~~~
p808.cpp:130:129: error: 'nullptr' was not declared in this scope
  130 | ng& str, size_t* idx = nullptr, int base = 10); float stof(const string& str, size_t* idx = nullptr);
      |                                                                                             ^~~~~~~

p808.cpp:131:46: error: 'nullptr' was not declared in this scope
  131 | double stod(const string& str, size_t* idx = nullptr);
      |                                              ^~~~~~~
p808.cpp:132:52: error: 'nullptr' was not declared in this scope
  132 | long double stold(const string& str, size_t* idx = nullptr);
      |                                                    ^~~~~~~
p808.cpp:142:44: error: 'nullptr' was not declared in this scope
  142 | int stoi(const wstring& str, size_t* idx = nullptr, int base = 10);
      |                                            ^~~~~~~
p808.cpp:143:45: error: 'nullptr' was not declared in this scope
  143 | long stol(const wstring& str, size_t* idx = nullptr, int base = 10);
      |                                             ^~~~~~~
p808.cpp:144:55: error: 'nullptr' was not declared in this scope
  144 | unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);
      |                                                       ^~~~~~~
p808.cpp:145:51: error: 'nullptr' was not declared in this scope
  145 | long long stoll(const wstring& str, size_t* idx = nullptr, int base = 10);
      |                                                   ^~~~~~~
p808.cpp:146:61: error: 'nullptr' was not declared in this scope
  146 | unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);
      |                                                             ^~~~~~~
p808.cpp:147:46: error: 'nullptr' was not declared in this scope
  147 | float stof(const wstring& str, size_t* idx = nullptr);
      |                                              ^~~~~~~
p808.cpp:148:47: error: 'nullptr' was not declared in this scope
  148 | double stod(const wstring& str, size_t* idx = nullptr);
      |                                               ^~~~~~~
p808.cpp:149:55: error: 'nullptr' was not declared in this scope
  149 |   long double stold(const wstring& str, size_t* idx = nullptr);
      |                                                       ^~~~~~~
p808.cpp:160:59: error: spurious '>>', use '>' to terminate a template argument list
  160 |     template<class charT, class traits = char_traits<charT>>
      |                                                           ^~
p808.cpp:161:7: error: expected '>' before 'using'
  161 |       using basic_string = std::basic_string<charT, traits, polymorphic_allocator<charT>>;
      |       ^~~~~
p808.cpp:161:90: error: expected unqualified-id before ';' token
  161 |       using basic_string = std::basic_string<charT, traits, polymorphic_allocator<charT>>;
      |                                                                                          ^
p808.cpp:162:11: error: expected nested-name-specifier before 'string'
  162 |     using string    = basic_string<char>;
      |           ^~~~~~
p808.cpp:163:11: error: expected nested-name-specifier before 'u8string'
  163 |     using u8string  = basic_string<char8_t>;
      |           ^~~~~~~~
p808.cpp:164:11: error: expected nested-name-specifier before 'u16string'
  164 |     using u16string = basic_string<char16_t>;
      |           ^~~~~~~~~
p808.cpp:165:11: error: expected nested-name-specifier before 'u32string'
  165 |     using u32string = basic_string<char32_t>;
      |           ^~~~~~~~~
p808.cpp:166:11: error: expected nested-name-specifier before 'wstring'
  166 |     using wstring   = basic_string<wchar_t>;
      |           ^~~~~~~
p808.cpp:169:87: error: 'u8string' was not declared in this scope
  169 | template<class T> struct hash; template<> struct hash<string>; template<> struct hash<u8string>; template<> struct hash<u16string>; template<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                       ^~~~~~~~
p808.cpp:169:87: note: 'std::u8string' is only available from C++20 onwards
p808.cpp:169:95: error: template argument 1 is invalid
  169 | late<class T> struct hash; template<> struct hash<string>; template<> struct hash<u8string>; template<> struct hash<u16string>; template<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                           ^

p808.cpp:169:121: error: 'u16string' was not declared in this scope
  169 |  template<> struct hash<string>; template<> struct hash<u8string>; template<> struct hash<u16string>; template<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                           ^~~~~~~~~

p808.cpp:169:121: note: 'std::u16string' is only available from C++11 onwards
p808.cpp:169:130: error: template argument 1 is invalid
  169 | <> struct hash<string>; template<> struct hash<u8string>; template<> struct hash<u16string>; template<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                           ^

p808.cpp:169:156: error: 'u32string' was not declared in this scope
  169 | mplate<> struct hash<u8string>; template<> struct hash<u16string>; template<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                           ^~~~~~~~~

p808.cpp:169:156: note: 'std::u32string' is only available from C++11 onwards
p808.cpp:169:165: error: template argument 1 is invalid
  169 | struct hash<u8string>; template<> struct hash<u16string>; template<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                           ^

p808.cpp:169:229: error: 'string' is not a member of 'std::pmr'; did you mean 'std::string'?
  169 | te<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                           ^~~~~~

In file included from /usr/local/include/c++/12.1.0/iosfwd:39,
                 from /usr/local/include/c++/12.1.0/ios:38,
                 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/bits/stringfwd.h:77:33: note: 'std::string' declared here
   77 |   typedef basic_string<char>    string;
      |                                 ^~~~~~
p808.cpp:169:229: error: 'string' is not a member of 'std::pmr'; did you mean 'std::string'?
  169 | te<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                           ^~~~~~

/usr/local/include/c++/12.1.0/bits/stringfwd.h:77:33: note: 'std::string' declared here
   77 |   typedef basic_string<char>    string;
      |                                 ^~~~~~
p808.cpp:169:235: error: template argument 1 is invalid
  169 | truct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                           ^

p808.cpp:169:266: error: 'u8string' is not a member of 'std::pmr'
  169 | <> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                           ^~~~~~~~

p808.cpp:169:266: error: 'u8string' is not a member of 'std::pmr'
p808.cpp:169:274: error: template argument 1 is invalid
  169 | t hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                           ^

p808.cpp:169:305: error: 'u16string' is not a member of 'std::pmr'
  169 | uct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                           ^~~~~~~~~

p808.cpp:169:305: error: 'u16string' is not a member of 'std::pmr'
p808.cpp:169:314: error: template argument 1 is invalid
  169 | pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                           ^

p808.cpp:169:345: error: 'u32string' is not a member of 'std::pmr'
  169 |  hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                           ^~~~~~~~~

p808.cpp:169:345: error: 'u32string' is not a member of 'std::pmr'
p808.cpp:169:354: error: template argument 1 is invalid
  169 | ::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                           ^

p808.cpp:169:385: error: 'wstring' is not a member of 'std::pmr'; did you mean 'std::wstring'?
  169 | t hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                             ^~~~~~~

/usr/local/include/c++/12.1.0/bits/stringfwd.h:80:33: note: 'std::wstring' declared here
   80 |   typedef basic_string<wchar_t> wstring;
      |                                 ^~~~~~~
p808.cpp:169:385: error: 'wstring' is not a member of 'std::pmr'; did you mean 'std::wstring'?
  169 | t hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                             ^~~~~~~

/usr/local/include/c++/12.1.0/bits/stringfwd.h:80:33: note: 'std::wstring' declared here
   80 |   typedef basic_string<wchar_t> wstring;
      |                                 ^~~~~~~
p808.cpp:169:392: error: template argument 1 is invalid
  169 | t hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
      |                                                                                                    ^

p808.cpp:173:1: error: 'constexpr' does not name a type
  173 | constexpr string operator""s(const char* str, size_t len); constexpr u8string operator""s(const char8_t* str, size_t len); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
      | ^~~~~~~~~
p808.cpp:173:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:173:60: error: 'constexpr' does not name a type
  173 | constexpr string operator""s(const char* str, size_t len); constexpr u8string operator""s(const char8_t* str, size_t len); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
      |                                                            ^~~~~~~~~
p808.cpp:173:60: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:173:124: error: 'constexpr' does not name a type
  173 | t char* str, size_t len); constexpr u8string operator""s(const char8_t* str, size_t len); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
      |                                                                                           ^~~~~~~~~

p808.cpp:173:124: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:173:190: error: 'constexpr' does not name a type
  173 | r8_t* str, size_t len); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
      |                                                                                           ^~~~~~~~~

p808.cpp:173:190: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:173:256: error: 'constexpr' does not name a type
  173 | 16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
      |                                                                                           ^~~~~~~~~

p808.cpp:173:256: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:183:50: error: spurious '>>', use '>' to terminate a template argument list
  183 |                 class Allocator = allocator<charT>>
      |                                                  ^~
p808.cpp:184:27: error: definition of 'class std::basic_string' inside template parameter list
  184 |        class basic_string {
      |                           ^
p808.cpp:183:35: error: two or more data types in declaration of 'type name'
  183 |                 class Allocator = allocator<charT>>
      |                                   ^~~~~~~~~~~~~~~~~
p808.cpp:401:3: error: expected '>' before 'template'
  401 |   template<class T>
      |   ^~~~~~~~
p808.cpp:403:69: error: expected unqualified-id before ';' token
  403 |                           size_type pos2, size_type n2 = npos) const;
      |                                                                     ^
p808.cpp:404:3: error: 'constexpr' does not name a type
  404 |   constexpr int compare(const basic_string& str) const noexcept;
      |   ^~~~~~~~~
p808.cpp:404:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:405:3: error: 'constexpr' does not name a type
  405 |   constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
      |   ^~~~~~~~~
p808.cpp:405:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:406:3: error: 'constexpr' does not name a type
  406 |   constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
      |   ^~~~~~~~~
p808.cpp:406:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:408:3: error: 'constexpr' does not name a type
  408 |   constexpr int compare(const charT* s) const;
      |   ^~~~~~~~~
p808.cpp:408:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:409:3: error: 'constexpr' does not name a type
  409 |   constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
      |   ^~~~~~~~~
p808.cpp:409:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:410:3: error: 'constexpr' does not name a type
  410 |   constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
      |   ^~~~~~~~~
p808.cpp:410:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:411:3: error: 'constexpr' does not name a type
  411 |   constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
      |   ^~~~~~~~~
p808.cpp:411:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:412:3: error: 'constexpr' does not name a type
  412 |   constexpr bool starts_with(charT x) const noexcept;
      |   ^~~~~~~~~
p808.cpp:412:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:413:3: error: 'constexpr' does not name a type
  413 |   constexpr bool starts_with(const charT* x) const;
      |   ^~~~~~~~~
p808.cpp:413:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:414:3: error: 'constexpr' does not name a type
  414 |   constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
      |   ^~~~~~~~~
p808.cpp:414:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:415:3: error: 'constexpr' does not name a type
  415 |   constexpr bool ends_with(charT x) const noexcept;
      |   ^~~~~~~~~
p808.cpp:415:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:416:3: error: 'constexpr' does not name a type
  416 |   constexpr bool ends_with(const charT* x) const;
      |   ^~~~~~~~~
p808.cpp:416:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:417:3: error: 'constexpr' does not name a type
  417 |   constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
      |   ^~~~~~~~~
p808.cpp:417:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:418:3: error: 'constexpr' does not name a type
  418 |   constexpr bool contains(charT x) const noexcept;
      |   ^~~~~~~~~
p808.cpp:418:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:419:3: error: 'constexpr' does not name a type
  419 |   constexpr bool contains(const charT* x) const;
      |   ^~~~~~~~~
p808.cpp:419:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:422:89: error: spurious '>>', use '>' to terminate a template argument list
  422 |          class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
      |                                                                                         ^~
p808.cpp:423:3: error: expected '>' before 'basic_string'
  423 |   basic_string(InputIterator, InputIterator, Allocator = Allocator())
      |   ^~~~~~~~~~~~
p808.cpp:426:31: error: expected unqualified-id before ';' token
  426 |                     Allocator>;
      |                               ^
p808.cpp:427:10: error: 'ranges' has not been declared
  427 | template<ranges::input_range R,
      |          ^~~~~~
p808.cpp:427:30: error: expected '>' before 'R'
  427 | template<ranges::input_range R,
      |                              ^
p808.cpp:431:11: error: expected unqualified-id before ';' token
  431 | Allocator>;
      |           ^
p808.cpp:434:43: error: spurious '>>', use '>' to terminate a template argument list
  434 |          class Allocator = allocator<charT>>
      |                                           ^~
p808.cpp:435:3: error: expected '>' before 'explicit'
  435 |   explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
      |   ^~~~~~~~
p808.cpp:436:46: error: expected unqualified-id before ';' token
  436 |     -> basic_string<charT, traits, Allocator>;
      |                                              ^
p808.cpp:439:43: error: spurious '>>', use '>' to terminate a template argument list
  439 |          class Allocator = allocator<charT>>
      |                                           ^~
p808.cpp:440:3: error: expected '>' before 'basic_string'
  440 |   basic_string(basic_string_view<charT, traits>,
      |   ^~~~~~~~~~~~
p808.cpp:443:42: error: expected unqualified-id before ';' token
  443 | -> basic_string<charT, traits, Allocator>;
      |                                          ^
p808.cpp:456:1: error: 'constexpr' does not name a type
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      | ^~~~~~~~~
p808.cpp:456:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:458:1: error: 'constexpr' does not name a type
  458 | constexpr basic_string(basic_string&& str) noexcept;
      | ^~~~~~~~~
p808.cpp:458:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:460:1: error: 'constexpr' does not name a type
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      | ^~~~~~~~~
p808.cpp:460:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:462:1: error: 'constexpr' does not name a type
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      | ^~~~~~~~~
p808.cpp:462:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:466:3: error: 'constexpr' does not name a type
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |   ^~~~~~~~~
p808.cpp:466:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:468:15: error: expected constructor, destructor, or type conversion before '(' token
  468 |   basic_string(sv.substr(pos, n), a);
      |               ^
p808.cpp:470:3: error: 'constexpr' does not name a type
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |   ^~~~~~~~~
p808.cpp:470:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:474:1: error: 'constexpr' does not name a type
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      | ^~~~~~~~~
p808.cpp:474:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:478:1: error: 'constexpr' does not name a type
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      | ^~~~~~~~~
p808.cpp:478:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:482:1: error: 'constexpr' does not name a type
  482 | constexpr basic_string& operator=(const basic_string& str);
      | ^~~~~~~~~
p808.cpp:482:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:483:1: error: 'constexpr' does not name a type
  483 | constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
      | ^~~~~~~~~
p808.cpp:483:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:487:3: error: 'constexpr' does not name a type
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |   ^~~~~~~~~
p808.cpp:487:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:490:10: error: 'container' has not been declared
  490 | template<container-compatible-range<charT> R>
      |          ^~~~~~~~~
p808.cpp:490:19: error: expected '>' before '-' token
  490 | template<container-compatible-range<charT> R>
      |                   ^
p808.cpp:491:1: error: 'constexpr' does not name a type
  491 | constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
      | ^~~~~~~~~
p808.cpp:491:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:494:1: error: 'constexpr' does not name a type
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      | ^~~~~~~~~
p808.cpp:494:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:495:1: error: 'constexpr' does not name a type
  495 | constexpr basic_string(basic_string&& str, const Allocator& alloc);
      | ^~~~~~~~~
p808.cpp:495:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:499:89: error: spurious '>>', use '>' to terminate a template argument list
  499 |          class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
      |                                                                                         ^~
p808.cpp:500:1: error: expected '>' before 'basic_string'
  500 | basic_string(InputIterator, InputIterator, Allocator = Allocator())
      | ^~~~~~~~~~~~
p808.cpp:503:29: error: expected unqualified-id before ';' token
  503 |                   Allocator>;
      |                             ^
p808.cpp:507:43: error: spurious '>>', use '>' to terminate a template argument list
  507 |          class Allocator = allocator<charT>>
      |                                           ^~
p808.cpp:508:3: error: expected '>' before 'explicit'
  508 |   explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
      |   ^~~~~~~~
p808.cpp:509:46: error: expected unqualified-id before ';' token
  509 |     -> basic_string<charT, traits, Allocator>;
      |                                              ^
p808.cpp:512:43: error: spurious '>>', use '>' to terminate a template argument list
  512 |          class Allocator = allocator<charT>>
      |                                           ^~
p808.cpp:513:3: error: expected '>' before 'basic_string'
  513 |   basic_string(basic_string_view<charT, traits>,
      |   ^~~~~~~~~~~~
p808.cpp:516:46: error: expected unqualified-id before ';' token
  516 |     -> basic_string<charT, traits, Allocator>;
      |                                              ^
p808.cpp:519:1: error: 'constexpr' does not name a type
  519 | constexpr basic_string& operator=(basic_string&& str)
      | ^~~~~~~~~
p808.cpp:519:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:524:1: error: 'constexpr' does not name a type
  524 | constexpr basic_string& operator=(const T& t);
      | ^~~~~~~~~
p808.cpp:524:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:528:8: error: expected unqualified-id before 'return'
  528 |        return assign(sv);
      |        ^~~~~~
p808.cpp:529:1: error: 'constexpr' does not name a type
  529 | constexpr basic_string& operator=(const charT* s);
      | ^~~~~~~~~
p808.cpp:529:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:531:1: error: 'constexpr' does not name a type
  531 | constexpr basic_string& operator=(charT c);
      | ^~~~~~~~~
p808.cpp:531:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:533:1: error: expected unqualified-id before 'return'
  533 | return *this = basic_string_view<charT, traits>(addressof(c), 1);
      | ^~~~~~
p808.cpp:534:1: error: 'constexpr' does not name a type
  534 | constexpr basic_string& operator=(initializer_list<charT> il);
      | ^~~~~~~~~
p808.cpp:534:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:536:1: error: expected unqualified-id before 'return'
  536 | return *this = basic_string_view<charT, traits>(il.begin(), il.size());
      | ^~~~~~
p808.cpp:538:1: error: 'constexpr' does not name a type
  538 | constexpr iterator       begin() noexcept;
      | ^~~~~~~~~
p808.cpp:538:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:539:1: error: 'constexpr' does not name a type
  539 | constexpr const_iterator begin() const noexcept;
      | ^~~~~~~~~
p808.cpp:539:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:540:1: error: 'constexpr' does not name a type
  540 | constexpr const_iterator cbegin() const noexcept;
      | ^~~~~~~~~
p808.cpp:540:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:542:1: error: 'constexpr' does not name a type
  542 | constexpr iterator       end() noexcept;
      | ^~~~~~~~~
p808.cpp:542:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:543:1: error: 'constexpr' does not name a type
  543 | constexpr const_iterator end() const noexcept;
      | ^~~~~~~~~
p808.cpp:543:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:544:1: error: 'constexpr' does not name a type
  544 | constexpr const_iterator cend() const noexcept;
      | ^~~~~~~~~
p808.cpp:544:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:546:1: error: 'constexpr' does not name a type
  546 | constexpr reverse_iterator       rbegin() noexcept;
      | ^~~~~~~~~
p808.cpp:546:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:547:1: error: 'constexpr' does not name a type
  547 | constexpr const_reverse_iterator rbegin() const noexcept;
      | ^~~~~~~~~
p808.cpp:547:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:548:1: error: 'constexpr' does not name a type
  548 | constexpr const_reverse_iterator crbegin() const noexcept;
      | ^~~~~~~~~
p808.cpp:548:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:550:1: error: 'constexpr' does not name a type
  550 | constexpr reverse_iterator       rend() noexcept;
      | ^~~~~~~~~
p808.cpp:550:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:551:1: error: 'constexpr' does not name a type
  551 | constexpr const_reverse_iterator rend() const noexcept;
      | ^~~~~~~~~
p808.cpp:551:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:552:1: error: 'constexpr' does not name a type
  552 | constexpr const_reverse_iterator crend() const noexcept;
      | ^~~~~~~~~
p808.cpp:552:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:555:1: error: 'constexpr' does not name a type
  555 | constexpr size_type size() const noexcept;
      | ^~~~~~~~~
p808.cpp:555:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:556:1: error: 'constexpr' does not name a type
  556 | constexpr size_type length() const noexcept;
      | ^~~~~~~~~
p808.cpp:556:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:558:6: error: 'constexpr' does not name a type
  558 |      constexpr size_type max_size() const noexcept;
      |      ^~~~~~~~~
p808.cpp:558:6: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:560:1: error: 'constexpr' does not name a type
  560 | constexpr void resize(size_type n, charT c);
      | ^~~~~~~~~
p808.cpp:560:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:563:1: error: 'constexpr' does not name a type
  563 | constexpr void resize(size_type n);
      | ^~~~~~~~~
p808.cpp:563:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:565:27: error: 'constexpr' does not name a type
  565 | template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
      |                           ^~~~~~~~~
p808.cpp:565:27: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:578:1: error: 'constexpr' does not name a type
  578 | constexpr size_type capacity() const noexcept;
      | ^~~~~~~~~
p808.cpp:578:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:580:1: error: 'constexpr' does not name a type
  580 | constexpr void reserve(size_type res_arg);
      | ^~~~~~~~~
p808.cpp:580:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:583:1: error: 'constexpr' does not name a type
  583 | constexpr void shrink_to_fit();
      | ^~~~~~~~~
p808.cpp:583:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:591:1: error: expected unqualified-id before '[' token
  591 | [[nodiscard]] constexpr bool empty() const noexcept;
      | ^
p808.cpp:594:1: error: 'constexpr' does not name a type
  594 | constexpr const_reference operator[](size_type pos) const;
      | ^~~~~~~~~
p808.cpp:594:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:595:1: error: 'constexpr' does not name a type
  595 | constexpr reference       operator[](size_type pos);
      | ^~~~~~~~~
p808.cpp:595:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:599:1: error: 'constexpr' does not name a type
  599 | constexpr const_reference at(size_type pos) const;
      | ^~~~~~~~~
p808.cpp:599:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:600:1: error: 'constexpr' does not name a type
  600 | constexpr reference       at(size_type pos);
      | ^~~~~~~~~
p808.cpp:600:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:603:1: error: 'constexpr' does not name a type
  603 | constexpr const charT& front() const;
      | ^~~~~~~~~
p808.cpp:603:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:604:1: error: 'constexpr' does not name a type
  604 | constexpr charT& front();
      | ^~~~~~~~~
p808.cpp:604:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:607:1: error: 'constexpr' does not name a type
  607 | constexpr const charT& back() const;
      | ^~~~~~~~~
p808.cpp:607:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:608:1: error: 'constexpr' does not name a type
  608 | constexpr charT& back();
      | ^~~~~~~~~
p808.cpp:608:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:613:1: error: 'constexpr' does not name a type
  613 | constexpr basic_string& operator+=(const basic_string& str);
      | ^~~~~~~~~
p808.cpp:613:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:615:1: error: expected unqualified-id before 'return'
  615 | return append(str);
      | ^~~~~~
p808.cpp:617:1: error: 'constexpr' does not name a type
  617 | constexpr basic_string& operator+=(const T& t);
      | ^~~~~~~~~
p808.cpp:617:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:620:1: error: 'basic_string_view' does not name a type
  620 | basic_string_view<charT, traits> sv = t;
      | ^~~~~~~~~~~~~~~~~
p808.cpp:621:8: error: expected unqualified-id before 'return'
  621 |        return append(sv);
      |        ^~~~~~
p808.cpp:622:1: error: 'constexpr' does not name a type
  622 | constexpr basic_string& operator+=(const charT* s);
      | ^~~~~~~~~
p808.cpp:622:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:624:1: error: expected unqualified-id before 'return'
  624 | return append(s); constexpr basic_string& operator+=(charT c);
      | ^~~~~~
p808.cpp:624:19: error: 'constexpr' does not name a type
  624 | return append(s); constexpr basic_string& operator+=(charT c);
      |                   ^~~~~~~~~
p808.cpp:624:19: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:626:1: error: expected unqualified-id before 'return'
  626 | return append(size_type{1}, c);
      | ^~~~~~
p808.cpp:626:27: error: expected unqualified-id before ',' token
  626 | return append(size_type{1}, c);
      |                           ^
p808.cpp:626:30: error: expected constructor, destructor, or type conversion before ')' token
  626 | return append(size_type{1}, c);
      |                              ^
p808.cpp:627:1: error: 'constexpr' does not name a type
  627 | constexpr basic_string& operator+=(initializer_list<charT> il);
      | ^~~~~~~~~
p808.cpp:627:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:630:1: error: 'constexpr' does not name a type
  630 | constexpr basic_string& append(const basic_string& str);
      | ^~~~~~~~~
p808.cpp:630:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:632:1: error: expected unqualified-id before 'return'
  632 | return append(str.data(), str.size());
      | ^~~~~~
p808.cpp:633:1: error: 'constexpr' does not name a type
  633 | constexpr basic_string& append(const basic_string& str, size_type pos, size_type n = npos);
      | ^~~~~~~~~
p808.cpp:633:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:635:1: error: expected unqualified-id before 'return'
  635 | return append(basic_string_view<charT, traits>(str).substr(pos, n));
      | ^~~~~~
p808.cpp:637:3: error: 'constexpr' does not name a type
  637 |   constexpr basic_string& append(const T& t);
      |   ^~~~~~~~~
p808.cpp:637:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:641:1: error: 'basic_string_view' does not name a type
  641 | basic_string_view<charT, traits> sv = t;
      | ^~~~~~~~~~~~~~~~~
p808.cpp:642:3: error: expected unqualified-id before 'return'
  642 |   return append(sv.data(), sv.size());
      |   ^~~~~~
p808.cpp:644:3: error: 'constexpr' does not name a type
  644 |   constexpr basic_string& append(const T& t, size_type pos, size_type n = npos);
      |   ^~~~~~~~~
p808.cpp:644:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:648:1: error: 'basic_string_view' does not name a type
  648 | basic_string_view<charT, traits> sv = t;
      | ^~~~~~~~~~~~~~~~~
p808.cpp:649:3: error: expected unqualified-id before 'return'
  649 |   return append(sv.substr(pos, n));
      |   ^~~~~~
p808.cpp:650:1: error: 'constexpr' does not name a type
  650 | constexpr basic_string& append(const charT* s, size_type n);
      | ^~~~~~~~~
p808.cpp:650:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:653:1: error: 'constexpr' does not name a type
  653 | constexpr basic_string& append(const charT* s);
      | ^~~~~~~~~
p808.cpp:653:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:655:1: error: expected unqualified-id before 'return'
  655 | return append(s, traits::length(s));
      | ^~~~~~
p808.cpp:656:1: error: 'constexpr' does not name a type
  656 | constexpr basic_string& append(size_type n, charT c);
      | ^~~~~~~~~
p808.cpp:656:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:659:3: error: 'constexpr' does not name a type
  659 |   constexpr basic_string& append(InputIterator first, InputIterator last);
      |   ^~~~~~~~~
p808.cpp:659:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:660:12: error: found ':' in nested-name-specifier, expected '::'
  660 | Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
      |            ^
      |            ::
p808.cpp:660:1: error: 'Constraints' does not name a type
  660 | Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
      | ^~~~~~~~~~~
p808.cpp:663:10: error: 'container' has not been declared
  663 | template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
      |          ^~~~~~~~~
p808.cpp:663:19: error: expected '>' before '-' token
  663 | template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
      |                   ^
p808.cpp:663:47: error: 'constexpr' does not name a type
  663 | template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
      |                                               ^~~~~~~~~
p808.cpp:663:47: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:665:1: error: expected unqualified-id before 'return'
  665 | return append(basic_string(from_range, std::forward<R>(rg), get_- allocator()));
      | ^~~~~~
p808.cpp:666:1: error: 'constexpr' does not name a type
  666 | constexpr basic_string& append(initializer_list<charT> il);
      | ^~~~~~~~~
p808.cpp:666:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:668:1: error: expected unqualified-id before 'return'
  668 | return append(il.begin(), il.size());
      | ^~~~~~
p808.cpp:669:6: error: 'constexpr' does not name a type
  669 |      constexpr void push_back(charT c);
      |      ^~~~~~~~~
p808.cpp:669:6: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:672:1: error: 'constexpr' does not name a type
  672 | constexpr basic_string& assign(const basic_string& str);
      | ^~~~~~~~~
p808.cpp:672:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:674:1: error: expected unqualified-id before 'return'
  674 | return *this = str;
      | ^~~~~~
p808.cpp:675:1: error: 'constexpr' does not name a type
  675 | constexpr basic_string& assign(basic_string&& str)
      | ^~~~~~~~~
p808.cpp:675:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:679:1: error: expected unqualified-id before 'return'
  679 | return *this = std::move(str);
      | ^~~~~~
p808.cpp:680:1: error: 'constexpr' does not name a type
  680 | constexpr basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);
      | ^~~~~~~~~
p808.cpp:680:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:682:1: error: expected unqualified-id before 'return'
  682 | return assign(basic_string_view<charT, traits>(str).substr(pos, n));
      | ^~~~~~
p808.cpp:684:3: error: 'constexpr' does not name a type
  684 |   constexpr basic_string& assign(const T& t);
      |   ^~~~~~~~~
p808.cpp:684:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:687:1: error: 'basic_string_view' does not name a type
  687 | basic_string_view<charT, traits> sv = t;
      | ^~~~~~~~~~~~~~~~~
p808.cpp:688:3: error: expected unqualified-id before 'return'
  688 |   return assign(sv.data(), sv.size());
      |   ^~~~~~
p808.cpp:690:3: error: 'constexpr' does not name a type
  690 |   constexpr basic_string& assign(const T& t, size_type pos, size_type n = npos);
      |   ^~~~~~~~~
p808.cpp:690:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:693:1: error: 'basic_string_view' does not name a type
  693 | basic_string_view<charT, traits> sv = t;
      | ^~~~~~~~~~~~~~~~~
p808.cpp:694:3: error: expected unqualified-id before 'return'
  694 |   return assign(sv.substr(pos, n));
      |   ^~~~~~
p808.cpp:695:1: error: 'constexpr' does not name a type
  695 | constexpr basic_string& assign(const charT* s, size_type n);
      | ^~~~~~~~~
p808.cpp:695:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:698:1: error: 'constexpr' does not name a type
  698 | constexpr basic_string& assign(const charT* s);
      | ^~~~~~~~~
p808.cpp:698:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:700:1: error: expected unqualified-id before 'return'
  700 | return assign(s, traits::length(s)); constexpr basic_string& assign(initializer_list<charT> il);
      | ^~~~~~
p808.cpp:700:38: error: 'constexpr' does not name a type
  700 | return assign(s, traits::length(s)); constexpr basic_string& assign(initializer_list<charT> il);
      |                                      ^~~~~~~~~
p808.cpp:700:38: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:702:1: error: expected unqualified-id before 'return'
  702 | return assign(il.begin(), il.size());
      | ^~~~~~
p808.cpp:703:1: error: 'constexpr' does not name a type
  703 | constexpr basic_string& assign(size_type n, charT c);
      | ^~~~~~~~~
p808.cpp:703:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:705:10: error: expected constructor, destructor, or type conversion before ';' token
  705 |   clear();
      |          ^
p808.cpp:706:9: error: expected constructor, destructor, or type conversion before '(' token
  706 |   resize(n, c);
      |         ^
p808.cpp:707:3: error: expected unqualified-id before 'return'
  707 |   return *this;
      |   ^~~~~~
p808.cpp:709:3: error: 'constexpr' does not name a type
  709 |   constexpr basic_string& assign(InputIterator first, InputIterator last);
      |   ^~~~~~~~~
p808.cpp:709:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:712:1: error: expected unqualified-id before 'return'
  712 | return assign(basic_string(first, last, get_allocator())); template<container-compatible-range<charT> R>
      | ^~~~~~
p808.cpp:712:69: error: 'container' has not been declared
  712 | return assign(basic_string(first, last, get_allocator())); template<container-compatible-range<charT> R>
      |                                                                     ^~~~~~~~~
p808.cpp:712:78: error: expected '>' before '-' token
  712 | return assign(basic_string(first, last, get_allocator())); template<container-compatible-range<charT> R>
      |                                                                              ^
p808.cpp:713:1: error: 'constexpr' does not name a type
  713 | constexpr basic_string& assign_range(R&& rg);
      | ^~~~~~~~~
p808.cpp:713:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:715:1: error: expected unqualified-id before 'return'
  715 | return assign(basic_string(from_range, std::forward<R>(rg), get_- allocator()));
      | ^~~~~~
p808.cpp:717:1: error: 'constexpr' does not name a type
  717 | constexpr basic_string& insert(size_type pos, const basic_string& str);
      | ^~~~~~~~~
p808.cpp:717:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:719:1: error: expected unqualified-id before 'return'
  719 | return insert(pos, str.data(), str.size());
      | ^~~~~~
p808.cpp:720:1: error: 'constexpr' does not name a type
  720 | constexpr basic_string& insert(size_type pos1, const basic_string& str,
      | ^~~~~~~~~
p808.cpp:720:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:723:1: error: expected unqualified-id before 'return'
  723 | return insert(pos1, basic_string_view<charT, traits>(str), pos2, n);
      | ^~~~~~
p808.cpp:725:3: error: 'constexpr' does not name a type
  725 |   constexpr basic_string& insert(size_type pos, const T& t);
      |   ^~~~~~~~~
p808.cpp:725:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:728:3: error: expected unqualified-id before 'return'
  728 |   return insert(pos, sv.data(), sv.size());
      |   ^~~~~~
p808.cpp:730:3: error: 'constexpr' does not name a type
  730 |   constexpr basic_string& insert(size_type pos1, const T& t,
      |   ^~~~~~~~~
p808.cpp:730:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:734:3: error: expected unqualified-id before 'return'
  734 |   return insert(pos1, sv.substr(pos2, n));
      |   ^~~~~~
p808.cpp:735:1: error: 'constexpr' does not name a type
  735 | constexpr basic_string& insert(size_type pos, const charT* s, size_type n);
      | ^~~~~~~~~
p808.cpp:735:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:741:1: error: 'constexpr' does not name a type
  741 | constexpr basic_string& insert(size_type pos, const charT* s);
      | ^~~~~~~~~
p808.cpp:741:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:743:1: error: 'constexpr' does not name a type
  743 | constexpr basic_string& insert(size_type pos, size_type n, charT c);
      | ^~~~~~~~~
p808.cpp:743:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:749:1: error: 'constexpr' does not name a type
  749 | constexpr iterator insert(const_iterator p, charT c);
      | ^~~~~~~~~
p808.cpp:749:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:753:1: error: 'constexpr' does not name a type
  753 | constexpr iterator insert(const_iterator p, size_type n, charT c);
      | ^~~~~~~~~
p808.cpp:753:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:758:3: error: 'constexpr' does not name a type
  758 |   constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
      |   ^~~~~~~~~
p808.cpp:758:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:762:10: error: 'container' has not been declared
  762 | template<container-compatible-range<charT> R>
      |          ^~~~~~~~~
p808.cpp:762:19: error: expected '>' before '-' token
  762 | template<container-compatible-range<charT> R>
      |                   ^
p808.cpp:763:1: error: 'constexpr' does not name a type
  763 | constexpr iterator insert_range(const_iterator p, R&& rg);
      | ^~~~~~~~~
p808.cpp:763:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:767:1: error: 'constexpr' does not name a type
  767 | constexpr iterator insert(const_iterator p, initializer_list<charT> il);
      | ^~~~~~~~~
p808.cpp:767:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:770:1: error: 'constexpr' does not name a type
  770 | constexpr basic_string& erase(size_type pos = 0, size_type n = npos);
      | ^~~~~~~~~
p808.cpp:770:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:774:1: error: 'constexpr' does not name a type
  774 | constexpr iterator erase(const_iterator p);
      | ^~~~~~~~~
p808.cpp:774:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:778:1: error: 'constexpr' does not name a type
  778 | constexpr iterator erase(const_iterator first, const_iterator last);
      | ^~~~~~~~~
p808.cpp:778:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:782:7: error: 'constexpr' does not name a type
  782 |       constexpr void pop_back();
      |       ^~~~~~~~~
p808.cpp:782:7: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:787:1: error: 'constexpr' does not name a type
  787 | constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
      | ^~~~~~~~~
p808.cpp:787:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:789:1: error: expected unqualified-id before 'return'
  789 | return replace(pos1, n1, str.data(), str.size()); constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
      | ^~~~~~
p808.cpp:789:51: error: 'constexpr' does not name a type
  789 | return replace(pos1, n1, str.data(), str.size()); constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
      |                                                   ^~~~~~~~~
p808.cpp:789:51: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:792:1: error: expected unqualified-id before 'return'
  792 | return replace(pos1, n1, basic_string_view<charT, traits>(str).substr(pos2, n2));
      | ^~~~~~
p808.cpp:794:3: error: 'constexpr' does not name a type
  794 |   constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);
      |   ^~~~~~~~~
p808.cpp:794:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:797:3: error: expected unqualified-id before 'return'
  797 |   return replace(pos1, n1, sv.data(), sv.size());
      |   ^~~~~~
p808.cpp:799:3: error: 'constexpr' does not name a type
  799 |   constexpr basic_string& replace(size_type pos1, size_type n1, const T& t,
      |   ^~~~~~~~~
p808.cpp:799:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:803:1: error: 'basic_string_view' does not name a type
  803 | basic_string_view<charT, traits> sv = t;
      | ^~~~~~~~~~~~~~~~~
p808.cpp:804:3: error: expected unqualified-id before 'return'
  804 |   return replace(pos1, n1, sv.substr(pos2, n2));
      |   ^~~~~~
p808.cpp:805:1: error: 'constexpr' does not name a type
  805 | constexpr basic_string& replace(size_type pos1, size_type n1, const charT* s, size_type n2);
      | ^~~~~~~~~
p808.cpp:805:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:810:1: error: 'constexpr' does not name a type
  810 | constexpr basic_string& replace(size_type pos, size_type n, const charT* s);
      | ^~~~~~~~~
p808.cpp:810:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:816:1: error: 'constexpr' does not name a type
  816 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
      | ^~~~~~~~~
p808.cpp:816:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:818:1: error: 'constexpr' does not name a type
  818 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);
      | ^~~~~~~~~
p808.cpp:818:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:822:6: error: 'basic_string_view' does not name a type
  822 |      basic_string_view<charT, traits> sv = t;
      |      ^~~~~~~~~~~~~~~~~
p808.cpp:823:6: error: expected unqualified-id before 'return'
  823 |      return replace(i1 - begin(), i2 - i1, sv.data(), sv.size());
      |      ^~~~~~
p808.cpp:824:1: error: 'constexpr' does not name a type
  824 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
      | ^~~~~~~~~
p808.cpp:824:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:827:1: error: 'constexpr' does not name a type
  827 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);
      | ^~~~~~~~~
p808.cpp:827:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:831:3: error: 'constexpr' does not name a type
  831 |   constexpr basic_string& replace(const_iterator i1, const_iterator i2,
      |   ^~~~~~~~~
p808.cpp:831:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:835:10: error: 'container' has not been declared
  835 | template<container-compatible-range<charT> R>
      |          ^~~~~~~~~
p808.cpp:835:19: error: expected '>' before '-' token
  835 | template<container-compatible-range<charT> R>
      |                   ^
p808.cpp:836:1: error: 'constexpr' does not name a type
  836 | constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg);
      | ^~~~~~~~~
p808.cpp:836:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:838:1: error: expected unqualified-id before 'return'
  838 | return replace(i1, i2, basic_string(from_range, std::forward<R>(rg), get_allocator()));
      | ^~~~~~
p808.cpp:839:1: error: 'constexpr' does not name a type
  839 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il);
      | ^~~~~~~~~
p808.cpp:839:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:842:1: error: 'constexpr' does not name a type
  842 | constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
      | ^~~~~~~~~
p808.cpp:842:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:844:1: error: expected unqualified-id before 'return'
  844 | return basic_string_view<charT, traits>(*this).copy(s, n, pos);
      | ^~~~~~
p808.cpp:847:1: error: 'constexpr' does not name a type
  847 | constexpr void swap(basic_string& s)
      | ^~~~~~~~~
p808.cpp:847:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:852:1: error: 'constexpr' does not name a type
  852 | constexpr size_type F(const basic_string& str, size_type pos) const noexcept;
      | ^~~~~~~~~
p808.cpp:852:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:854:1: error: expected unqualified-id before 'return'
  854 | return F (basic_string_view<charT, traits>(str), pos);
      | ^~~~~~
p808.cpp:856:1: error: 'constexpr' does not name a type
  856 | constexpr size_type F(const charT* s, size_type pos) const;
      | ^~~~~~~~~
p808.cpp:856:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:858:1: error: expected unqualified-id before 'return'
  858 | return F (basic_string_view<charT, traits>(s), pos);
      | ^~~~~~
p808.cpp:860:1: error: 'constexpr' does not name a type
  860 | constexpr size_type F(const charT* s, size_type pos, size_type n) const;
      | ^~~~~~~~~
p808.cpp:860:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:863:1: error: 'constexpr' does not name a type
  863 | constexpr size_type F(charT c, size_type pos) const noexcept; has effects equivalent to:
      | ^~~~~~~~~
p808.cpp:863:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:863:63: error: 'has' does not name a type
  863 | constexpr size_type F(charT c, size_type pos) const noexcept; has effects equivalent to:
      |                                                               ^~~
p808.cpp:866:1: error: 'constexpr' does not name a type
  866 | constexpr size_type find(const T& t, size_type pos = 0) const noexcept(see below);
      | ^~~~~~~~~
p808.cpp:866:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:868:1: error: 'constexpr' does not name a type
  868 | constexpr size_type rfind(const T& t, size_type pos = npos) const noexcept(see_below);
      | ^~~~~~~~~
p808.cpp:868:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:870:1: error: 'constexpr' does not name a type
  870 | constexpr size_type find_first_of(const T& t, size_type pos = 0) const noexcept(see_below);
      | ^~~~~~~~~
p808.cpp:870:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:872:1: error: 'constexpr' does not name a type
  872 | constexpr size_type find_last_of(const T& t, size_type pos = npos) const noexcept(see_below);
      | ^~~~~~~~~
p808.cpp:872:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:874:1: error: 'constexpr' does not name a type
  874 | constexpr size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept(see_below);
      | ^~~~~~~~~
p808.cpp:874:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:880:1: error: 'constexpr' does not name a type
  880 | constexpr const charT* c_str() const noexcept;
      | ^~~~~~~~~
p808.cpp:880:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:881:1: error: 'constexpr' does not name a type
  881 | constexpr const charT* data() const noexcept;
      | ^~~~~~~~~
p808.cpp:881:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:884:1: error: 'constexpr' does not name a type
  884 | constexpr charT* data() noexcept;
      | ^~~~~~~~~
p808.cpp:884:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:887:1: error: 'constexpr' does not name a type
  887 | constexpr operator basic_string_view<charT, traits>() const noexcept;
      | ^~~~~~~~~
p808.cpp:887:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:892:1: error: 'constexpr' does not name a type
  892 | constexpr size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept(see below);
      | ^~~~~~~~~
p808.cpp:892:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:895:1: error: expected unqualified-id before 'return'
  895 | return s.G(sv, pos);
      | ^~~~~~
p808.cpp:898:1: error: 'constexpr' does not name a type
  898 | constexpr basic_string substr(size_type pos = 0, size_type n = npos) const;
      | ^~~~~~~~~
p808.cpp:898:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:902:1: error: 'constexpr' does not name a type
  902 | constexpr int compare(const T& t) const noexcept(see_below);
      | ^~~~~~~~~
p808.cpp:902:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:908:3: error: 'constexpr' does not name a type
  908 |   constexpr int compare(size_type pos1, size_type n1, const T& t) const;
      |   ^~~~~~~~~
p808.cpp:908:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:911:1: error: expected unqualified-id before 'return'
  911 | return basic_string_view<charT, traits>(*this).substr(pos1, n1).compare(t);
      | ^~~~~~
p808.cpp:913:3: error: 'constexpr' does not name a type
  913 |   constexpr int compare(size_type pos1, size_type n1, const T& t,
      |   ^~~~~~~~~
p808.cpp:913:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:917:1: error: 'basic_string_view' does not name a type
  917 | basic_string_view<charT, traits> s = *this, sv = t;
      | ^~~~~~~~~~~~~~~~~
p808.cpp:918:8: error: expected unqualified-id before 'return'
  918 |        return s.substr(pos1, n1).compare(sv.substr(pos2, n2));
      |        ^~~~~~
p808.cpp:919:1: error: 'constexpr' does not name a type
  919 | constexpr int compare(const basic_string& str) const noexcept;
      | ^~~~~~~~~
p808.cpp:919:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:922:34: error: 'charT' was not declared in this scope; did you mean 'char'?
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                  ^~~~~
      |                                  char
p808.cpp:922:41: error: 'traits' was not declared in this scope
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                         ^~~~~~
p808.cpp:922:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                                 ^~~~~~~~~
      |                                                 alloca
p808.cpp:922:58: error: template argument 1 is invalid
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                                          ^
p808.cpp:922:58: error: template argument 2 is invalid
p808.cpp:922:58: error: template argument 3 is invalid
p808.cpp:922:72: error: 'charT' does not name a type; did you mean 'char'?
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                                                        ^~~~~
      |                                                                        char
p808.cpp:922:83: error: expected constructor, destructor, or type conversion before ';' token
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                                                                   ^
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                     ^~~~~
      |                     char
p808.cpp:924:28: error: 'traits' was not declared in this scope
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                            ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                                    ^~~~~~~~~
      |                                    alloca
p808.cpp:924:45: error: template argument 1 is invalid
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                                             ^
p808.cpp:924:45: error: template argument 2 is invalid
p808.cpp:924:45: error: template argument 3 is invalid
p808.cpp:924:51: error: 'lhs' was not declared in this scope
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                                                   ^~~
p808.cpp:925:8: error: 'r' does not name a type
  925 |        r.append(rhs);
      |        ^
p808.cpp:926:8: error: expected unqualified-id before 'return'
  926 |        return r;
      |        ^~~~~~
p808.cpp:928:3: error: 'constexpr' does not name a type
  928 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:928:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:931:4: error: 'constexpr' does not name a type
  931 |    constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
      |    ^~~~~~~~~
p808.cpp:931:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:934:1: error: expected unqualified-id before 'return'
  934 | return compare(pos1, n1, basic_string_view<charT, traits>(str), pos2, n2);
      | ^~~~~~
p808.cpp:935:1: error: 'constexpr' does not name a type
  935 | constexpr int compare(const charT* s) const;
      | ^~~~~~~~~
p808.cpp:935:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:938:1: error: 'constexpr' does not name a type
  938 | constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
      | ^~~~~~~~~
p808.cpp:938:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:941:1: error: 'constexpr' does not name a type
  941 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
      | ^~~~~~~~~
p808.cpp:941:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:942:1: error: 'constexpr' does not name a type
  942 | constexpr bool starts_with(charT x) const noexcept;
      | ^~~~~~~~~
p808.cpp:942:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:943:1: error: 'constexpr' does not name a type
  943 | constexpr bool starts_with(const charT* x) const;
      | ^~~~~~~~~
p808.cpp:943:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:945:1: error: expected unqualified-id before 'return'
  945 | return basic_string_view<charT, traits>(data(), size()).starts_with(x);
      | ^~~~~~
p808.cpp:947:1: error: 'constexpr' does not name a type
  947 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
      | ^~~~~~~~~
p808.cpp:947:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:948:1: error: 'constexpr' does not name a type
  948 | constexpr bool ends_with(charT x) const noexcept;
      | ^~~~~~~~~
p808.cpp:948:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:949:1: error: 'constexpr' does not name a type
  949 | constexpr bool ends_with(const charT* x) const;
      | ^~~~~~~~~
p808.cpp:949:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:951:1: error: expected unqualified-id before 'return'
  951 | return basic_string_view<charT, traits>(data(), size()).ends_with(x);
      | ^~~~~~
p808.cpp:953:1: error: 'constexpr' does not name a type
  953 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
      | ^~~~~~~~~
p808.cpp:953:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:954:1: error: 'constexpr' does not name a type
  954 | constexpr bool contains(charT x) const noexcept;
      | ^~~~~~~~~
p808.cpp:954:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:955:1: error: 'constexpr' does not name a type
  955 | constexpr bool contains(const charT* x) const;
      | ^~~~~~~~~
p808.cpp:955:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:957:1: error: expected unqualified-id before 'return'
  957 | return basic_string_view<charT, traits>(data(), size()).contains(x);
      | ^~~~~~
p808.cpp:961:3: error: 'constexpr' does not name a type
  961 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:961:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:965:3: error: 'constexpr' does not name a type
  965 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:965:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:970:8: error: expected unqualified-id before 'return'
  970 |        return std::move(lhs);
      |        ^~~~~~
p808.cpp:971:17: error: 'charT' does not name a type; did you mean 'char'?
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                 ^~~~~
      |                 char
p808.cpp:971:42: error: 'charT' was not declared in this scope; did you mean 'char'?
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                          ^~~~~
      |                                          char
p808.cpp:971:49: error: 'traits' was not declared in this scope
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                                 ^~~~~~
p808.cpp:971:57: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                                         ^~~~~~~~~
      |                                                         alloca
p808.cpp:971:66: error: template argument 1 is invalid
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                                                  ^
p808.cpp:971:66: error: template argument 2 is invalid
p808.cpp:971:66: error: template argument 3 is invalid
p808.cpp:971:67: error: expected ',' or '...' before '&&' token
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                                                   ^~
p808.cpp:971:74: error: expected constructor, destructor, or type conversion before ';' token
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                                                          ^
p808.cpp:973:4: error: expected unqualified-id before 'return'
  973 |    return std::move(rhs);
      |    ^~~~~~
p808.cpp:975:3: error: 'constexpr' does not name a type
  975 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:975:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:979:4: error: expected unqualified-id before 'return'
  979 |    return std::move(lhs);
      |    ^~~~~~
p808.cpp:983:3: error: 'constexpr' does not name a type
  983 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:983:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:987:3: error: 'constexpr' does not name a type
  987 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:987:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:992:24: error: 'traits' was not declared in this scope
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:992:41: error: template argument 1 is invalid
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                         ^
p808.cpp:992:41: error: template argument 2 is invalid
p808.cpp:992:41: error: template argument 3 is invalid
p808.cpp:992:43: error: redefinition of 'int r'
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                           ^
p808.cpp:924:47: note: 'int r' previously defined here
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                                               ^
p808.cpp:992:47: error: 'rhs' was not declared in this scope
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                               ^~~
p808.cpp:993:4: error: 'r' does not name a type
  993 |    r.insert(0, lhs);
      |    ^
p808.cpp:994:4: error: expected unqualified-id before 'return'
  994 |    return r;
      |    ^~~~~~
p808.cpp:996:3: error: 'constexpr' does not name a type
  996 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:996:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:999:24: error: 'traits' was not declared in this scope
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:999:41: error: template argument 1 is invalid
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                         ^
p808.cpp:999:41: error: template argument 2 is invalid
p808.cpp:999:41: error: template argument 3 is invalid
p808.cpp:999:43: error: redefinition of 'int r'
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                           ^
p808.cpp:924:47: note: 'int r' previously defined here
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                                               ^
p808.cpp:999:47: error: 'rhs' was not declared in this scope
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                               ^~~
p808.cpp:1000:4: error: 'r' does not name a type
 1000 |    r.insert(r.begin(), lhs);
      |    ^
p808.cpp:1001:4: error: expected unqualified-id before 'return'
 1001 |    return r;
      |    ^~~~~~
p808.cpp:1003:3: error: 'constexpr' does not name a type
 1003 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:1003:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1006:4: error: expected unqualified-id before 'return'
 1006 |    return std::move(rhs);
      |    ^~~~~~
p808.cpp:1008:3: error: 'constexpr' does not name a type
 1008 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:1008:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                 ^~~~~
      |                 char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                        ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:1011:41: error: template argument 1 is invalid
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                                         ^
p808.cpp:1011:41: error: template argument 2 is invalid
p808.cpp:1011:41: error: template argument 3 is invalid
p808.cpp:1011:43: error: redefinition of 'int r'
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                                           ^
p808.cpp:924:47: note: 'int r' previously defined here
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                                               ^
p808.cpp:1011:47: error: 'lhs' was not declared in this scope
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                                               ^~~
p808.cpp:1012:4: error: 'r' does not name a type
 1012 |    r.push_back(rhs);
      |    ^
p808.cpp:1013:4: error: expected unqualified-id before 'return'
 1013 |    return r;
      |    ^~~~~~
p808.cpp:1014:1: error: 'constexpr' does not name a type
 1014 | constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      | ^~~~~~~~~
p808.cpp:1014:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1016:1: error: expected unqualified-id before 'return'
 1016 | return basic_string_view<charT, traits>(lhs) op basic_string_view<charT, traits>(rhs);
      | ^~~~~~
p808.cpp:1018:3: error: 'constexpr' does not name a type
 1018 |   constexpr basic_string<charT, traits, Allocator>
      |   ^~~~~~~~~
p808.cpp:1018:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1021:8: error: expected unqualified-id before 'return'
 1021 |        return std::move(lhs);
      |        ^~~~~~
p808.cpp:1024:3: error: 'constexpr' does not name a type
 1024 |   constexpr bool
      |   ^~~~~~~~~
p808.cpp:1024:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1028:3: error: 'constexpr' does not name a type
 1028 |   constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
      |   ^~~~~~~~~
p808.cpp:1028:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1031:1: error: 'constexpr' does not name a type
 1031 | constexpr see_below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
      | ^~~~~~~~~
p808.cpp:1031:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1035:10: error: declaration of template parameter 'charT' shadows template parameter
 1035 | template<class charT, class traits, class Allocator>
      |          ^~~~~
p808.cpp:1033:10: note: template parameter 'charT' declared here
 1033 | template<class charT, class traits, class Allocator>
      |          ^~~~~
p808.cpp:1035:23: error: declaration of template parameter 'traits' shadows template parameter
 1035 | template<class charT, class traits, class Allocator>
      |                       ^~~~~
p808.cpp:1033:23: note: template parameter 'traits' declared here
 1033 | template<class charT, class traits, class Allocator>
      |                       ^~~~~
p808.cpp:1035:37: error: declaration of template parameter 'Allocator' shadows template parameter
 1035 | template<class charT, class traits, class Allocator>
      |                                     ^~~~~
p808.cpp:1033:37: note: template parameter 'Allocator' declared here
 1033 | template<class charT, class traits, class Allocator>
      |                                     ^~~~~
p808.cpp:1036:3: error: 'constexpr' does not name a type
 1036 |   constexpr void
      |   ^~~~~~~~~
p808.cpp:1036:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1063:41: error: expected ',' or '...' before '&&' token
 1063 |     getline(basic_istream<charT, traits>&& is,
      |                                         ^~
p808.cpp:1078:37: error: expected ',' or '...' before '&&' token
 1078 | getline(basic_istream<charT, traits>&& is,
      |                                     ^~
p808.cpp:1083:3: error: 'constexpr' does not name a type
 1083 |   constexpr typename basic_string<charT, traits, Allocator>::size_type
      |   ^~~~~~~~~
p808.cpp:1083:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1086:4: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
 1086 |    auto it = remove(c.begin(), c.end(), value);
      |    ^~~~
      |    ----
p808.cpp:1086:9: error: 'it' does not name a type; did you mean 'int'?
 1086 |    auto it = remove(c.begin(), c.end(), value);
      |         ^~
      |         int
p808.cpp:1087:4: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
 1087 |    auto r = distance(it, c.end());
      |    ^~~~
      |    ----
p808.cpp:1087:9: error: 'r' does not name a type
 1087 |    auto r = distance(it, c.end());
      |         ^
p808.cpp:1088:4: error: 'c' does not name a type
 1088 |    c.erase(it, c.end());
      |    ^
p808.cpp:1089:4: error: expected unqualified-id before 'return'
 1089 |    return r;
      |    ^~~~~~
p808.cpp:1091:3: error: 'constexpr' does not name a type
 1091 |   constexpr typename basic_string<charT, traits, Allocator>::size_type
      |   ^~~~~~~~~
p808.cpp:1091:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1094:4: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
 1094 |    auto it = remove_if(c.begin(), c.end(), pred);
      |    ^~~~
      |    ----
p808.cpp:1094:9: error: 'it' does not name a type; did you mean 'int'?
 1094 |    auto it = remove_if(c.begin(), c.end(), pred);
      |         ^~
      |         int
p808.cpp:1095:4: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
 1095 |    auto r = distance(it, c.end());
      |    ^~~~
      |    ----
p808.cpp:1095:9: error: 'r' does not name a type
 1095 |    auto r = distance(it, c.end());
      |         ^
p808.cpp:1096:4: error: 'c' does not name a type
 1096 |    c.erase(it, c.end());
      |    ^
p808.cpp:1097:4: error: expected unqualified-id before 'return'
 1097 |    return r;
      |    ^~~~~~
p808.cpp:1100:46: error: 'nullptr' was not declared in this scope
 1100 |    int stoi(const string& str, size_t* idx = nullptr, int base = 10);
      |                                              ^~~~~~~
p808.cpp:1101:47: error: 'nullptr' was not declared in this scope
 1101 |    long stol(const string& str, size_t* idx = nullptr, int base = 10);
      |                                               ^~~~~~~
p808.cpp:1102:57: error: 'nullptr' was not declared in this scope
 1102 |    unsigned long stoul(const string& str, size_t* idx = nullptr, int base = 10);
      |                                                         ^~~~~~~
p808.cpp:1103:53: error: 'nullptr' was not declared in this scope
 1103 |    long long stoll(const string& str, size_t* idx = nullptr, int base = 10);
      |                                                     ^~~~~~~
p808.cpp:1104:63: error: 'nullptr' was not declared in this scope
 1104 |    unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10);
      |                                                               ^~~~~~~
p808.cpp:1108:45: error: 'nullptr' was not declared in this scope
 1108 | float stof(const string& str, size_t* idx = nullptr);
      |                                             ^~~~~~~
p808.cpp:1109:46: error: 'nullptr' was not declared in this scope
 1109 | double stod(const string& str, size_t* idx = nullptr);
      |                                              ^~~~~~~
p808.cpp:1110:52: error: 'nullptr' was not declared in this scope
 1110 | long double stold(const string& str, size_t* idx = nullptr);
      |                                                    ^~~~~~~
p808.cpp:1123:44: error: 'nullptr' was not declared in this scope
 1123 | int stoi(const wstring& str, size_t* idx = nullptr, int base = 10);
      |                                            ^~~~~~~
p808.cpp:1124:45: error: 'nullptr' was not declared in this scope
 1124 | long stol(const wstring& str, size_t* idx = nullptr, int base = 10);
      |                                             ^~~~~~~
p808.cpp:1125:55: error: 'nullptr' was not declared in this scope
 1125 | unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);
      |                                                       ^~~~~~~
p808.cpp:1126:51: error: 'nullptr' was not declared in this scope
 1126 | long long stoll(const wstring& str, size_t* idx = nullptr, int base = 10);
      |                                                   ^~~~~~~
p808.cpp:1127:61: error: 'nullptr' was not declared in this scope
 1127 | unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);
      |                                                             ^~~~~~~
p808.cpp:1133:46: error: 'nullptr' was not declared in this scope
 1133 | float stof(const wstring& str, size_t* idx = nullptr);
      |                                              ^~~~~~~
p808.cpp:1134:47: error: 'nullptr' was not declared in this scope
 1134 | double stod(const wstring& str, size_t* idx = nullptr);
      |                                               ^~~~~~~
p808.cpp:1135:53: error: 'nullptr' was not declared in this scope
 1135 | long double stold(const wstring& str, size_t* idx = nullptr);
      |                                                     ^~~~~~~
p808.cpp:1150:19: error: explicit specialization of 'template<class T> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
 1150 | template<> struct hash<string>;
      |                   ^~~~~~~~~~~~
p808.cpp:1151:24: error: 'u8string' was not declared in this scope
 1151 | template<> struct hash<u8string>;
      |                        ^~~~~~~~
p808.cpp:1151:24: note: 'std::u8string' is only available from C++20 onwards
p808.cpp:1151:32: error: template argument 1 is invalid
 1151 | template<> struct hash<u8string>;
      |                                ^
p808.cpp:1152:24: error: 'u16string' was not declared in this scope
 1152 | template<> struct hash<u16string>;
      |                        ^~~~~~~~~
p808.cpp:1152:24: note: 'std::u16string' is only available from C++11 onwards
p808.cpp:1152:33: error: template argument 1 is invalid
 1152 | template<> struct hash<u16string>;
      |                                 ^
p808.cpp:1153:24: error: 'u32string' was not declared in this scope
 1153 | template<> struct hash<u32string>;
      |                        ^~~~~~~~~
p808.cpp:1153:24: note: 'std::u32string' is only available from C++11 onwards
p808.cpp:1153:33: error: template argument 1 is invalid
 1153 | template<> struct hash<u32string>;
      |                                 ^
p808.cpp:1154:19: error: explicit specialization of 'template<class T> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
 1154 | template<> struct hash<wstring>;
      |                   ^~~~~~~~~~~~~
p808.cpp:1155:29: error: 'string' is not a member of 'std::pmr'; did you mean 'std::string'?
 1155 | template<> struct hash<pmr::string>;
      |                             ^~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:77:33: note: 'std::string' declared here
   77 |   typedef basic_string<char>    string;
      |                                 ^~~~~~
p808.cpp:1155:29: error: 'string' is not a member of 'std::pmr'; did you mean 'std::string'?
 1155 | template<> struct hash<pmr::string>;
      |                             ^~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:77:33: note: 'std::string' declared here
   77 |   typedef basic_string<char>    string;
      |                                 ^~~~~~
p808.cpp:1155:35: error: template argument 1 is invalid
 1155 | template<> struct hash<pmr::string>;
      |                                   ^
p808.cpp:1156:29: error: 'u8string' is not a member of 'std::pmr'
 1156 | template<> struct hash<pmr::u8string>;
      |                             ^~~~~~~~
p808.cpp:1156:29: error: 'u8string' is not a member of 'std::pmr'
p808.cpp:1156:37: error: template argument 1 is invalid
 1156 | template<> struct hash<pmr::u8string>;
      |                                     ^
p808.cpp:1157:29: error: 'u16string' is not a member of 'std::pmr'
 1157 | template<> struct hash<pmr::u16string>;
      |                             ^~~~~~~~~
p808.cpp:1157:29: error: 'u16string' is not a member of 'std::pmr'
p808.cpp:1157:38: error: template argument 1 is invalid
 1157 | template<> struct hash<pmr::u16string>;
      |                                      ^
p808.cpp:1158:29: error: 'u32string' is not a member of 'std::pmr'
 1158 | template<> struct hash<pmr::u32string>;
      |                             ^~~~~~~~~
p808.cpp:1158:29: error: 'u32string' is not a member of 'std::pmr'
p808.cpp:1158:38: error: template argument 1 is invalid
 1158 | template<> struct hash<pmr::u32string>;
      |                                      ^
p808.cpp:1159:29: error: 'wstring' is not a member of 'std::pmr'; did you mean 'std::wstring'?
 1159 | template<> struct hash<pmr::wstring>;
      |                             ^~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:80:33: note: 'std::wstring' declared here
   80 |   typedef basic_string<wchar_t> wstring;
      |                                 ^~~~~~~
p808.cpp:1159:29: error: 'wstring' is not a member of 'std::pmr'; did you mean 'std::wstring'?
 1159 | template<> struct hash<pmr::wstring>;
      |                             ^~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:80:33: note: 'std::wstring' declared here
   80 |   typedef basic_string<wchar_t> wstring;
      |                                 ^~~~~~~
p808.cpp:1159:36: error: template argument 1 is invalid
 1159 | template<> struct hash<pmr::wstring>;
      |                                    ^
p808.cpp:1161:1: error: 'constexpr' does not name a type
 1161 | constexpr string operator""s(const char* str, size_t len);
      | ^~~~~~~~~
p808.cpp:1161:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1163:1: error: 'constexpr' does not name a type
 1163 | constexpr u8string operator""s(const char8_t* str, size_t len);
      | ^~~~~~~~~
p808.cpp:1163:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1165:1: error: 'constexpr' does not name a type
 1165 | constexpr u16string operator""s(const char16_t* str, size_t len);
      | ^~~~~~~~~
p808.cpp:1165:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1167:1: error: 'constexpr' does not name a type
 1167 | constexpr u32string operator""s(const char32_t* str, size_t len);
      | ^~~~~~~~~
p808.cpp:1167:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1169:1: error: 'constexpr' does not name a type
 1169 | constexpr wstring operator""s(const wchar_t* str, size_t len);
      | ^~~~~~~~~
p808.cpp:1169:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'

$ g++ p808.cpp -std=2b -o p808g -I. -Wall
p808.cpp:660:75: error: too many decimal points in number
  660 | Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
      |                                                                           ^~~~~~~~
p808.cpp:24:17: error: reference to 'basic_string' is ambiguous
   24 |       constexpr basic_string<charT, traits, Allocator>
      |                 ^~~~~~~~~~~~
In file included from /usr/local/include/c++/12.1.0/iosfwd:39,
                 from /usr/local/include/c++/12.1.0/ios:38,
                 from /usr/local/include/c++/12.1.0/ostream:38,
                 from /usr/local/include/c++/12.1.0/iostream:39,
                 from N4910.h:2,
                 from p808.cpp:10:
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:28:17: error: reference to 'basic_string' is ambiguous
   28 |       constexpr basic_string<charT, traits, Allocator>
      |                 ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:32:17: error: reference to 'basic_string' is ambiguous
   32 |       constexpr basic_string<charT, traits, Allocator>
      |                 ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:36:13: error: reference to 'basic_string' is ambiguous
   36 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:40:13: error: reference to 'basic_string' is ambiguous
   40 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:44:13: error: reference to 'basic_string' is ambiguous
   44 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:48:13: error: reference to 'basic_string' is ambiguous
   48 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:52:13: error: reference to 'basic_string' is ambiguous
   52 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:56:13: error: reference to 'basic_string' is ambiguous
   56 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:60:13: error: reference to 'basic_string' is ambiguous
   60 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:64:13: error: reference to 'basic_string' is ambiguous
   64 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:68:13: error: reference to 'basic_string' is ambiguous
   68 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:73:22: error: reference to 'basic_string' is ambiguous
   73 |     operator==(const basic_string<charT, traits, Allocator>& lhs,
      |                      ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:73:34: error: expected ',' or '...' before '<' token
   73 |     operator==(const basic_string<charT, traits, Allocator>& lhs,
      |                                  ^
p808.cpp:73:5: error: 'constexpr bool std::operator==(int)' must have an argument of class or enumerated type
   73 |     operator==(const basic_string<charT, traits, Allocator>& lhs,
      |     ^~~~~~~~
p808.cpp:76:35: error: reference to 'basic_string' is ambiguous
   76 |   constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
      |                                   ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:76:47: error: expected ',' or '...' before '<' token
   76 |   constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
      |                                               ^
p808.cpp:76:18: error: 'constexpr bool std::operator==(int)' must have an argument of class or enumerated type
   76 |   constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
      |                  ^~~~~~~~
p808.cpp:79:11: error: 'see' does not name a type
   79 | constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
      |           ^~~
p808.cpp:82:11: error: 'see' does not name a type
   82 | constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |           ^~~
p808.cpp:86:5: error: variable or field 'swap' declared void
   86 |     swap(basic_string<charT, traits, Allocator>& lhs,
      |     ^~~~
p808.cpp:86:10: error: reference to 'basic_string' is ambiguous
   86 |     swap(basic_string<charT, traits, Allocator>& lhs,
      |          ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:86:28: error: expected primary-expression before ',' token
   86 |     swap(basic_string<charT, traits, Allocator>& lhs,
      |                            ^
p808.cpp:86:36: error: expected primary-expression before ',' token
   86 |     swap(basic_string<charT, traits, Allocator>& lhs,
      |                                    ^
p808.cpp:86:47: error: expected primary-expression before '>' token
   86 |     swap(basic_string<charT, traits, Allocator>& lhs,
      |                                               ^
p808.cpp:86:50: error: 'lhs' was not declared in this scope
   86 |     swap(basic_string<charT, traits, Allocator>& lhs,
      |                                                  ^~~
p808.cpp:87:10: error: reference to 'basic_string' is ambiguous
   87 |          basic_string<charT, traits, Allocator>& rhs)
      |          ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:87:28: error: expected primary-expression before ',' token
   87 |          basic_string<charT, traits, Allocator>& rhs)
      |                            ^
p808.cpp:87:36: error: expected primary-expression before ',' token
   87 |          basic_string<charT, traits, Allocator>& rhs)
      |                                    ^
p808.cpp:87:47: error: expected primary-expression before '>' token
   87 |          basic_string<charT, traits, Allocator>& rhs)
      |                                               ^
p808.cpp:87:50: error: 'rhs' was not declared in this scope
   87 |          basic_string<charT, traits, Allocator>& rhs)
      |                                                  ^~~
p808.cpp:93:1: error: reference to 'basic_string' is ambiguous
   93 | basic_string<charT, traits, Allocator>& str);
      | ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:93:1: error: 'basic_string' has not been declared
   93 | basic_string<charT, traits, Allocator>& str);
      | ^~~~~~~~~~~~
p808.cpp:93:13: error: expected ',' or '...' before '<' token
   93 | basic_string<charT, traits, Allocator>& str);
      |             ^
p808.cpp:97:22: error: reference to 'basic_string' is ambiguous
   97 |                const basic_string<charT, traits, Allocator>& str);
      |                      ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:97:34: error: expected ',' or '...' before '<' token
   97 |                const basic_string<charT, traits, Allocator>& str);
      |                                  ^
p808.cpp:101:13: error: reference to 'basic_string' is ambiguous
  101 |             basic_string<charT, traits, Allocator>& str,
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:101:13: error: 'basic_string' has not been declared
  101 |             basic_string<charT, traits, Allocator>& str,
      |             ^~~~~~~~~~~~
p808.cpp:101:25: error: expected ',' or '...' before '<' token
  101 |             basic_string<charT, traits, Allocator>& str,
      |                         ^
p808.cpp:106:13: error: reference to 'basic_string' is ambiguous
  106 |             basic_string<charT, traits, Allocator>& str,
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:106:13: error: 'basic_string' has not been declared
  106 |             basic_string<charT, traits, Allocator>& str,
      |             ^~~~~~~~~~~~
p808.cpp:106:25: error: expected ',' or '...' before '<' token
  106 |             basic_string<charT, traits, Allocator>& str,
      |                         ^
p808.cpp:111:13: error: reference to 'basic_string' is ambiguous
  111 |             basic_string<charT, traits, Allocator>& str);
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:111:13: error: 'basic_string' has not been declared
  111 |             basic_string<charT, traits, Allocator>& str);
      |             ^~~~~~~~~~~~
p808.cpp:111:25: error: expected ',' or '...' before '<' token
  111 |             basic_string<charT, traits, Allocator>& str);
      |                         ^
p808.cpp:115:13: error: reference to 'basic_string' is ambiguous
  115 |             basic_string<charT, traits, Allocator>& str);
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:115:13: error: 'basic_string' has not been declared
  115 |             basic_string<charT, traits, Allocator>& str);
      |             ^~~~~~~~~~~~
p808.cpp:115:25: error: expected ',' or '...' before '<' token
  115 |             basic_string<charT, traits, Allocator>& str);
      |                         ^
p808.cpp:118:22: error: expected nested-name-specifier before 'basic_string'
  118 |   constexpr typename basic_string<charT, traits, Allocator>::size_type
      |                      ^~~~~~~~~~~~
p808.cpp:118:34: error: expected initializer before '<' token
  118 |   constexpr typename basic_string<charT, traits, Allocator>::size_type
      |                                  ^
p808.cpp:121:22: error: expected nested-name-specifier before 'basic_string'
  121 |   constexpr typename basic_string<charT, traits, Allocator>::size_type
      |                      ^~~~~~~~~~~~
p808.cpp:121:34: error: expected initializer before '<' token
  121 |   constexpr typename basic_string<charT, traits, Allocator>::size_type
      |                                  ^
p808.cpp:124:16: error: reference to 'basic_string' is ambiguous
  124 | using string = basic_string<char>; using u8string = basic_string<char8_t>; using u16string = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
      |                ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:124:53: error: reference to 'basic_string' is ambiguous
  124 | using string = basic_string<char>; using u8string = basic_string<char8_t>; using u16string = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
      |                                                     ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:124:94: error: reference to 'basic_string' is ambiguous
  124 | ng string = basic_string<char>; using u8string = basic_string<char8_t>; using u16string = basic_strin<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
      |                                                                                           ^~~~~~~~~~~

/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:124:136: error: reference to 'basic_string' is ambiguous
  124 | ring = basic_string<char8_t>; using u16string = basic_string<char16_t>; using u32string = basic_strin<char32_t>; using wstring = basic_string<wchar_t>;
      |                                                                                           ^~~~~~~~~~~

/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:124:176: error: reference to 'basic_string' is ambiguous
  124 | tring = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_strin<wchar_t>;
      |                                                                                           ^~~~~~~~~~~

/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:161:28: error: reference to 'basic_string' is ambiguous
  161 |       using basic_string = std::basic_string<charT, traits, polymorphic_allocator<charT>>;
      |                            ^~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:173:18: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
  173 | constexpr string operator""s(const char* str, size_t len); constexpr u8string operator""s(const char8_t* str, size_t len); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
      |                  ^~~~~~~~
p808.cpp:173:79: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
  173 | constexpr string operator""s(const char* str, size_t len); constexpr u8string operator""s(const char8_t* str, size_t len); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
      |                                                                               ^~~~~~~~
p808.cpp:173:144: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
  173 | len); constexpr u8string operator""s(const char8_t* str, size_t len); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
      |                                                                                           ^~~~~~~~

p808.cpp:173:210: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
  173 | n); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
      |                                                                                           ^~~~~~~~

p808.cpp:173:274: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
  173 | len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
      |                                                                                           ^~~~~~~~

p808.cpp:182:30: error: redefinition of default argument for 'class traits'
  182 |        template<class charT, class traits = char_traits<charT>,
      |                              ^~~~~
p808.cpp:21:23: note: original definition appeared here
   21 | template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
      |                       ^~~~~
p808.cpp:404:31: error: reference to 'basic_string' is ambiguous
  404 |   constexpr int compare(const basic_string& str) const noexcept;
      |                               ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note:                 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
p808.cpp:404:56: error: non-member function 'constexpr int std::compare(const int&)' cannot have cv-qualifier
  404 |   constexpr int compare(const basic_string& str) const noexcept;
      |                                                        ^~~~~~~~
p808.cpp:405:25: error: 'constexpr const int std::compare' redeclared as different kind of entity
  405 |   constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
      |                         ^~~~~~~~~
p808.cpp:404:17: note: previous declaration 'constexpr int std::compare(const int&)'
  404 |   constexpr int compare(const basic_string& str) const noexcept;
      |                 ^~~~~~~
p808.cpp:405:25: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
  405 |   constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
      |                         ^~~~~~~~~
      |                         true_type
p808.cpp:405:41: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
  405 |   constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
      |                                         ^~~~~~~~~
      |                                         true_type
p808.cpp:405:55: error: expected primary-expression before 'const'
  405 |   constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
      |                                                       ^~~~~
p808.cpp:406:25: error: 'constexpr const int std::compare' redeclared as different kind of entity
  406 |   constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
      |                         ^~~~~~~~~
p808.cpp:404:17: note: previous declaration 'constexpr int std::compare(const int&)'
  404 |   constexpr int compare(const basic_string& str) const noexcept;
      |                 ^~~~~~~
p808.cpp:406:25: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
  406 |   constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
      |                         ^~~~~~~~~
      |                         true_type
p808.cpp:406:41: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
  406 |   constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
      |                                         ^~~~~~~~~
      |                                         true_type
p808.cpp:406:55: error: expected primary-expression before 'const'
  406 |   constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
      |                                                       ^~~~~
p808.cpp:407:25: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
  407 |                         size_type pos2, size_type n2 = npos) const;
      |                         ^~~~~~~~~
      |                         true_type
p808.cpp:407:41: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
  407 |                         size_type pos2, size_type n2 = npos) const;
      |                                         ^~~~~~~~~
      |                                         true_type
p808.cpp:408:31: error: 'charT' does not name a type; did you mean 'char'?
  408 |   constexpr int compare(const charT* s) const;
      |                               ^~~~~
      |                               char
p808.cpp:408:41: error: non-member function 'constexpr int std::compare(const int*)' cannot have cv-qualifier
  408 |   constexpr int compare(const charT* s) const;
      |                                         ^~~~~
p808.cpp:409:25: error: 'constexpr const int std::compare' redeclared as different kind of entity
  409 |   constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
      |                         ^~~~~~~~~
p808.cpp:408:17: note: previous declaration 'constexpr int std::compare(const int*)'
  408 |   constexpr int compare(const charT* s) const;
      |                 ^~~~~~~
p808.cpp:409:25: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
  409 |   constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
      |                         ^~~~~~~~~
      |                         true_type
p808.cpp:409:41: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
  409 |   constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
      |                                         ^~~~~~~~~
      |                                         true_type
p808.cpp:409:55: error: expected primary-expression before 'const'
  409 |   constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
      |                                                       ^~~~~
p808.cpp:410:25: error: 'constexpr const int std::compare' redeclared as different kind of entity
  410 |   constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
      |                         ^~~~~~~~~
p808.cpp:408:17: note: previous declaration 'constexpr int std::compare(const int*)'
  408 |   constexpr int compare(const charT* s) const;
      |                 ^~~~~~~
p808.cpp:410:25: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
  410 |   constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
      |                         ^~~~~~~~~
      |                         true_type
p808.cpp:410:41: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
  410 |   constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
      |                                         ^~~~~~~~~
      |                                         true_type
p808.cpp:410:55: error: expected primary-expression before 'const'
  410 |   constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
      |                                                       ^~~~~
p808.cpp:410:71: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
  410 |   constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
      |                                                                       ^~~~~~~~~
      |                                                                       true_type
p808.cpp:411:48: error: 'charT' was not declared in this scope; did you mean 'char'?
  411 |   constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
      |                                                ^~~~~
      |                                                char
p808.cpp:411:55: error: 'traits' was not declared in this scope
  411 |   constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
      |                                                       ^~~~~~
p808.cpp:411:61: error: template argument 1 is invalid
  411 |   constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
      |                                                             ^
p808.cpp:411:61: error: template argument 2 is invalid
p808.cpp:411:72: error: non-member function 'constexpr bool std::starts_with(int)' cannot have cv-qualifier
  411 |   constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
      |                                                                        ^~~~~~~~
p808.cpp:412:30: error: 'constexpr const bool std::starts_with' redeclared as different kind of entity
  412 |   constexpr bool starts_with(charT x) const noexcept;
      |                              ^~~~~
p808.cpp:411:18: note: previous declaration 'constexpr bool std::starts_with(int)'
  411 |   constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
      |                  ^~~~~~~~~~~
p808.cpp:412:30: error: 'charT' was not declared in this scope; did you mean 'char'?
  412 |   constexpr bool starts_with(charT x) const noexcept;
      |                              ^~~~~
      |                              char
p808.cpp:413:36: error: 'charT' does not name a type; did you mean 'char'?
  413 |   constexpr bool starts_with(const charT* x) const;
      |                                    ^~~~~
      |                                    char
p808.cpp:413:46: error: non-member function 'constexpr bool std::starts_with(const int*)' cannot have cv-qualifier
  413 |   constexpr bool starts_with(const charT* x) const;
      |                                              ^~~~~
p808.cpp:414:46: error: 'charT' was not declared in this scope; did you mean 'char'?
  414 |   constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
      |                                              ^~~~~
      |                                              char
p808.cpp:414:53: error: 'traits' was not declared in this scope
  414 |   constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
      |                                                     ^~~~~~
p808.cpp:414:59: error: template argument 1 is invalid
  414 |   constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
      |                                                           ^
p808.cpp:414:59: error: template argument 2 is invalid
p808.cpp:414:70: error: non-member function 'constexpr bool std::ends_with(int)' cannot have cv-qualifier
  414 |   constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
      |                                                                      ^~~~~~~~
p808.cpp:415:28: error: 'constexpr const bool std::ends_with' redeclared as different kind of entity
  415 |   constexpr bool ends_with(charT x) const noexcept;
      |                            ^~~~~
p808.cpp:414:18: note: previous declaration 'constexpr bool std::ends_with(int)'
  414 |   constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
      |                  ^~~~~~~~~
p808.cpp:415:28: error: 'charT' was not declared in this scope; did you mean 'char'?
  415 |   constexpr bool ends_with(charT x) const noexcept;
      |                            ^~~~~
      |                            char
p808.cpp:416:34: error: 'charT' does not name a type; did you mean 'char'?
  416 |   constexpr bool ends_with(const charT* x) const;
      |                                  ^~~~~
      |                                  char
p808.cpp:416:44: error: non-member function 'constexpr bool std::ends_with(const int*)' cannot have cv-qualifier
  416 |   constexpr bool ends_with(const charT* x) const;
      |                                            ^~~~~
p808.cpp:417:45: error: 'charT' was not declared in this scope; did you mean 'char'?
  417 |   constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
      |                                             ^~~~~
      |                                             char
p808.cpp:417:52: error: 'traits' was not declared in this scope
  417 |   constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
      |                                                    ^~~~~~
p808.cpp:417:58: error: template argument 1 is invalid
  417 |   constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
      |                                                          ^
p808.cpp:417:58: error: template argument 2 is invalid
p808.cpp:417:69: error: non-member function 'constexpr bool std::contains(int)' cannot have cv-qualifier
  417 |   constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
      |                                                                     ^~~~~~~~
p808.cpp:418:27: error: 'constexpr const bool std::contains' redeclared as different kind of entity
  418 |   constexpr bool contains(charT x) const noexcept;
      |                           ^~~~~
p808.cpp:417:18: note: previous declaration 'constexpr bool std::contains(int)'
  417 |   constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
      |                  ^~~~~~~~
p808.cpp:418:27: error: 'charT' was not declared in this scope; did you mean 'char'?
  418 |   constexpr bool contains(charT x) const noexcept;
      |                           ^~~~~
      |                           char
p808.cpp:419:33: error: 'charT' does not name a type; did you mean 'char'?
  419 |   constexpr bool contains(const charT* x) const;
      |                                 ^~~~~
      |                                 char
p808.cpp:419:43: error: non-member function 'constexpr bool std::contains(const int*)' cannot have cv-qualifier
  419 |   constexpr bool contains(const charT* x) const;
      |                                           ^~~~~
p808.cpp:424:8: error: reference to 'basic_string' is ambiguous
  424 |     -> basic_string<typename iterator_traits<InputIterator>::value_type,
      |        ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:423:3: error: reference to 'basic_string' is ambiguous
  423 |   basic_string(InputIterator, InputIterator, Allocator = Allocator())
      |   ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:424:20: error: expected constructor, destructor, or type conversion before '<' token
  424 |     -> basic_string<typename iterator_traits<InputIterator>::value_type,
      |                    ^
p808.cpp:429:15: error: expected constructor, destructor, or type conversion before '(' token
  429 |   basic_string(from_range_t, R&&, Allocator = Allocator())
      |               ^
p808.cpp:436:8: error: reference to 'basic_string' is ambiguous
  436 |     -> basic_string<charT, traits, Allocator>;
      |        ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:435:12: error: reference to 'basic_string' is ambiguous
  435 |   explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
      |            ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:436:20: error: expected initializer before '<' token
  436 |     -> basic_string<charT, traits, Allocator>;
      |                    ^
p808.cpp:441:10: error: expected nested-name-specifier before 'see'
  441 | typename see below::size_type, typename see below::size_type,
      |          ^~~
p808.cpp:441:14: error: expected ',' or '...' before 'below'
  441 | typename see below::size_type, typename see below::size_type,
      |              ^~~~~
p808.cpp:443:4: error: reference to 'basic_string' is ambiguous
  443 | -> basic_string<charT, traits, Allocator>;
      |    ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:440:3: error: reference to 'basic_string' is ambiguous
  440 |   basic_string(basic_string_view<charT, traits>,
      |   ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:443:16: error: expected constructor, destructor, or type conversion before '<' token
  443 | -> basic_string<charT, traits, Allocator>;
      |                ^
p808.cpp:456:39: error: 'Allocator' does not name a type; did you mean 'alloca'?
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                                       ^~~~~~~~~
      |                                       alloca
p808.cpp:456:20: error: reference to 'basic_string' is ambiguous
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:456:20: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:456:11: error: 'explicit' outside class declaration
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |           ^~~~~~~~
p808.cpp:458:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
  458 | constexpr basic_string(basic_string&& str) noexcept;
      |           ^~~~~~~~~~~~
p808.cpp:458:24: error: 'constexpr const int basic_string' redeclared as different kind of entity
  458 | constexpr basic_string(basic_string&& str) noexcept;
      |                        ^~~~~~~~~~~~
p808.cpp:456:20: note: previous declaration 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:458:24: error: reference to 'basic_string' is ambiguous
  458 | constexpr basic_string(basic_string&& str) noexcept;
      |                        ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:458:39: error: 'str' was not declared in this scope; did you mean 'std'?
  458 | constexpr basic_string(basic_string&& str) noexcept;
      |                                       ^~~
      |                                       std
p808.cpp:460:30: error: reference to 'basic_string' is ambiguous
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |                              ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:460:49: error: 'size_type' has not been declared
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |                                                 ^~~~~~~~~
p808.cpp:461:30: error: 'Allocator' does not name a type; did you mean 'alloca'?
  461 |                        const Allocator& a = Allocator());
      |                              ^~~~~~~~~
      |                              alloca
p808.cpp:461:45: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  461 |                        const Allocator& a = Allocator());
      |                                             ^~~~~~~~~
      |                                             alloca
p808.cpp:460:11: error: reference to 'basic_string' is ambiguous
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:460:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:462:30: error: reference to 'basic_string' is ambiguous
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |                              ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:462:49: error: 'size_type' has not been declared
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |                                                 ^~~~~~~~~
p808.cpp:462:64: error: 'size_type' has not been declared
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |                                                                ^~~~~~~~~
p808.cpp:463:30: error: 'Allocator' does not name a type; did you mean 'alloca'?
  463 |                        const Allocator& a = Allocator());
      |                              ^~~~~~~~~
      |                              alloca
p808.cpp:463:45: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  463 |                        const Allocator& a = Allocator());
      |                                             ^~~~~~~~~
      |                                             alloca
p808.cpp:462:11: error: reference to 'basic_string' is ambiguous
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:462:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:466:38: error: 'size_type' has not been declared
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |                                      ^~~~~~~~~
p808.cpp:466:53: error: 'size_type' has not been declared
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |                                                     ^~~~~~~~~
p808.cpp:466:72: error: 'Allocator' does not name a type; did you mean 'alloca'?
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |                                                                        ^~~~~~~~~
      |                                                                        alloca
p808.cpp:466:87: error: there are no arguments to 'Allocator' that depend on a template parameter, so a declaration of 'Allocator' must be available [-fpermissive]
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |                                                                                       ^~~~~~~~~
p808.cpp:466:87: note: (if you use '-fpermissive', G++ will accept your code, but allowing the use of an undeclared name is deprecated)
p808.cpp:466:13: error: reference to 'basic_string' is ambiguous
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:466:13: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:468:15: error: expected constructor, destructor, or type conversion before '(' token
  468 |   basic_string(sv.substr(pos, n), a);
      |               ^
p808.cpp:470:53: error: 'Allocator' does not name a type; did you mean 'alloca'?
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                                                     ^~~~~~~~~
      |                                                     alloca
p808.cpp:470:68: error: there are no arguments to 'Allocator' that depend on a template parameter, so a declaration of 'Allocator' must be available [-fpermissive]
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                                                                    ^~~~~~~~~
p808.cpp:470:22: error: reference to 'basic_string' is ambiguous
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:470:22: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:470:13: error: 'explicit' outside class declaration
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |             ^~~~~~~~
p808.cpp:474:30: error: 'charT' does not name a type; did you mean 'char'?
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |                              ^~~~~
      |                              char
p808.cpp:474:40: error: 'size_type' has not been declared
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |                                        ^~~~~~~~~
p808.cpp:474:59: error: 'Allocator' does not name a type; did you mean 'alloca'?
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |                                                           ^~~~~~~~~
      |                                                           alloca
p808.cpp:474:74: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |                                                                          ^~~~~~~~~
      |                                                                          alloca
p808.cpp:474:11: error: reference to 'basic_string' is ambiguous
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:474:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:478:30: error: 'charT' does not name a type; did you mean 'char'?
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |                              ^~~~~
      |                              char
p808.cpp:478:46: error: 'Allocator' does not name a type; did you mean 'alloca'?
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |                                              ^~~~~~~~~
      |                                              alloca
p808.cpp:478:61: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |                                                             ^~~~~~~~~
      |                                                             alloca
p808.cpp:478:11: error: reference to 'basic_string' is ambiguous
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:478:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:482:11: error: reference to 'basic_string' is ambiguous
  482 | constexpr basic_string& operator=(const basic_string& str);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:483:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
  483 | constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:483:24: error: 'constexpr const int basic_string' redeclared as different kind of entity
  483 | constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
      |                        ^~~~~~~~~
p808.cpp:478:11: note: previous declaration 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:483:24: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  483 | constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
      |                        ^~~~~~~~~
      |                        size_t
p808.cpp:483:37: error: 'charT' was not declared in this scope; did you mean 'char'?
  483 | constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
      |                                     ^~~~~
      |                                     char
p808.cpp:483:46: error: expected primary-expression before 'const'
  483 | constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
      |                                              ^~~~~
p808.cpp:487:72: error: 'Allocator' does not name a type; did you mean 'alloca'?
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |                                                                        ^~~~~~~~~
      |                                                                        alloca
p808.cpp:487:87: error: there are no arguments to 'Allocator' that depend on a template parameter, so a declaration of 'Allocator' must be available [-fpermissive]
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |                                                                                       ^~~~~~~~~
p808.cpp:487:13: error: reference to 'basic_string' is ambiguous
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:487:13: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:490:10: error: 'container' has not been declared
  490 | template<container-compatible-range<charT> R>
      |          ^~~~~~~~~
p808.cpp:490:19: error: expected '>' before '-' token
  490 | template<container-compatible-range<charT> R>
      |                   ^
p808.cpp:491:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
  491 | constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:491:24: error: 'template<<typeprefixerror><anonymous> > constexpr const int basic_string' redeclared as different kind of entity
  491 | constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
      |                        ^~~~~~~~~~~~
p808.cpp:478:11: note: previous declaration 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:491:24: error: 'from_range_t' was not declared in this scope
  491 | constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
      |                        ^~~~~~~~~~~~
p808.cpp:491:38: error: 'R' was not declared in this scope
  491 | constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
      |                                      ^
p808.cpp:491:42: error: 'rg' was not declared in this scope
  491 | constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
      |                                          ^~
p808.cpp:491:46: error: expected primary-expression before 'const'
  491 | constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
      |                                              ^~~~~
p808.cpp:494:30: error: reference to 'basic_string' is ambiguous
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |                              ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:494:55: error: 'Allocator' does not name a type; did you mean 'alloca'?
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |                                                       ^~~~~~~~~
      |                                                       alloca
p808.cpp:494:11: error: reference to 'basic_string' is ambiguous
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:494:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:495:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
  495 | constexpr basic_string(basic_string&& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:495:24: error: 'constexpr const int basic_string' redeclared as different kind of entity
  495 | constexpr basic_string(basic_string&& str, const Allocator& alloc);
      |                        ^~~~~~~~~~~~
p808.cpp:494:11: note: previous declaration 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:495:24: error: reference to 'basic_string' is ambiguous
  495 | constexpr basic_string(basic_string&& str, const Allocator& alloc);
      |                        ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:495:39: error: 'str' was not declared in this scope; did you mean 'std'?
  495 | constexpr basic_string(basic_string&& str, const Allocator& alloc);
      |                                       ^~~
      |                                       std
p808.cpp:495:44: error: expected primary-expression before 'const'
  495 | constexpr basic_string(basic_string&& str, const Allocator& alloc);
      |                                            ^~~~~
p808.cpp:501:6: error: reference to 'basic_string' is ambiguous
  501 |   -> basic_string<typename iterator_traits<InputIterator>::value_type,
      |      ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:500:1: error: reference to 'basic_string' is ambiguous
  500 | basic_string(InputIterator, InputIterator, Allocator = Allocator())
      | ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:501:18: error: expected constructor, destructor, or type conversion before '<' token
  501 |   -> basic_string<typename iterator_traits<InputIterator>::value_type,
      |                  ^
p808.cpp:509:8: error: reference to 'basic_string' is ambiguous
  509 |     -> basic_string<charT, traits, Allocator>;
      |        ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:508:12: error: reference to 'basic_string' is ambiguous
  508 |   explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
      |            ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:509:20: error: expected initializer before '<' token
  509 |     -> basic_string<charT, traits, Allocator>;
      |                    ^
p808.cpp:514:10: error: expected nested-name-specifier before 'see'
  514 | typename see below::size_type, typename see below::size_type,
      |          ^~~
p808.cpp:514:14: error: expected ',' or '...' before 'below'
  514 | typename see below::size_type, typename see below::size_type,
      |              ^~~~~
p808.cpp:516:8: error: reference to 'basic_string' is ambiguous
  516 |     -> basic_string<charT, traits, Allocator>;
      |        ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:513:3: error: reference to 'basic_string' is ambiguous
  513 |   basic_string(basic_string_view<charT, traits>,
      |   ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:516:20: error: expected constructor, destructor, or type conversion before '<' token
  516 |     -> basic_string<charT, traits, Allocator>;
      |                    ^
p808.cpp:519:11: error: reference to 'basic_string' is ambiguous
  519 | constexpr basic_string& operator=(basic_string&& str)
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:524:11: error: reference to 'basic_string' is ambiguous
  524 | constexpr basic_string& operator=(const T& t);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:528:8: error: expected unqualified-id before 'return'
  528 |        return assign(sv);
      |        ^~~~~~
p808.cpp:529:11: error: reference to 'basic_string' is ambiguous
  529 | constexpr basic_string& operator=(const charT* s);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:531:11: error: reference to 'basic_string' is ambiguous
  531 | constexpr basic_string& operator=(charT c);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:533:1: error: expected unqualified-id before 'return'
  533 | return *this = basic_string_view<charT, traits>(addressof(c), 1);
      | ^~~~~~
p808.cpp:534:11: error: reference to 'basic_string' is ambiguous
  534 | constexpr basic_string& operator=(initializer_list<charT> il);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:536:1: error: expected unqualified-id before 'return'
  536 | return *this = basic_string_view<charT, traits>(il.begin(), il.size());
      | ^~~~~~
p808.cpp:538:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  538 | constexpr iterator       begin() noexcept;
      |           ^~~~~~~~
In file included from /usr/local/include/c++/12.1.0/bits/stl_construct.h:61,
                 from /usr/local/include/c++/12.1.0/bits/char_traits.h:46,
                 from /usr/local/include/c++/12.1.0/ios:40:
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p808.cpp:538:11: error: deduced class type 'iterator' in function return type
  538 | constexpr iterator       begin() noexcept;
      |           ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p808.cpp:539:11: error: 'const_iterator' does not name a type
  539 | constexpr const_iterator begin() const noexcept;
      |           ^~~~~~~~~~~~~~
p808.cpp:540:11: error: 'const_iterator' does not name a type
  540 | constexpr const_iterator cbegin() const noexcept;
      |           ^~~~~~~~~~~~~~
p808.cpp:542:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  542 | constexpr iterator       end() noexcept;
      |           ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p808.cpp:542:11: error: deduced class type 'iterator' in function return type
  542 | constexpr iterator       end() noexcept;
      |           ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p808.cpp:543:11: error: 'const_iterator' does not name a type
  543 | constexpr const_iterator end() const noexcept;
      |           ^~~~~~~~~~~~~~
p808.cpp:544:11: error: 'const_iterator' does not name a type
  544 | constexpr const_iterator cend() const noexcept;
      |           ^~~~~~~~~~~~~~
p808.cpp:546:11: error: deduced class type 'reverse_iterator' in function return type
  546 | constexpr reverse_iterator       rbegin() noexcept;
      |           ^~~~~~~~~~~~~~~~
In file included from /usr/local/include/c++/12.1.0/string:47,
                 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/stl_iterator.h:132:11: note: 'template<class _Iterator> class std::reverse_iterator' declared here
  132 |     class reverse_iterator
      |           ^~~~~~~~~~~~~~~~
p808.cpp:547:11: error: 'const_reverse_iterator' does not name a type
  547 | constexpr const_reverse_iterator rbegin() const noexcept;
      |           ^~~~~~~~~~~~~~~~~~~~~~
p808.cpp:548:11: error: 'const_reverse_iterator' does not name a type
  548 | constexpr const_reverse_iterator crbegin() const noexcept;
      |           ^~~~~~~~~~~~~~~~~~~~~~
p808.cpp:550:11: error: deduced class type 'reverse_iterator' in function return type
  550 | constexpr reverse_iterator       rend() noexcept;
      |           ^~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator.h:132:11: note: 'template<class _Iterator> class std::reverse_iterator' declared here
  132 |     class reverse_iterator
      |           ^~~~~~~~~~~~~~~~
p808.cpp:551:11: error: 'const_reverse_iterator' does not name a type
  551 | constexpr const_reverse_iterator rend() const noexcept;
      |           ^~~~~~~~~~~~~~~~~~~~~~
p808.cpp:552:11: error: 'const_reverse_iterator' does not name a type
  552 | constexpr const_reverse_iterator crend() const noexcept;
      |           ^~~~~~~~~~~~~~~~~~~~~~
p808.cpp:555:11: error: 'size_type' does not name a type; did you mean 'size_t'?
  555 | constexpr size_type size() const noexcept;
      |           ^~~~~~~~~
      |           size_t
p808.cpp:556:11: error: 'size_type' does not name a type; did you mean 'size_t'?
  556 | constexpr size_type length() const noexcept;
      |           ^~~~~~~~~
      |           size_t
p808.cpp:558:16: error: 'size_type' does not name a type; did you mean 'size_t'?
  558 |      constexpr size_type max_size() const noexcept;
      |                ^~~~~~~~~
      |                size_t
p808.cpp:560:16: error: variable or field 'resize' declared void
  560 | constexpr void resize(size_type n, charT c);
      |                ^~~~~~
p808.cpp:560:23: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  560 | constexpr void resize(size_type n, charT c);
      |                       ^~~~~~~~~
      |                       size_t
p808.cpp:560:36: error: 'charT' was not declared in this scope; did you mean 'char'?
  560 | constexpr void resize(size_type n, charT c);
      |                                    ^~~~~
      |                                    char
p808.cpp:563:16: error: variable or field 'resize' declared void
  563 | constexpr void resize(size_type n);
      |                ^~~~~~
p808.cpp:563:23: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  563 | constexpr void resize(size_type n);
      |                       ^~~~~~~~~
      |                       size_t
p808.cpp:565:42: error: variable or field 'resize_and_overwrite' declared void
  565 | template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
      |                                          ^~~~~~~~~~~~~~~~~~~~
p808.cpp:565:63: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  565 | template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
      |                                                               ^~~~~~~~~
      |                                                               size_t
p808.cpp:565:86: error: expected primary-expression before 'op'
  565 | template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
      |                                                                                      ^~
p808.cpp:578:11: error: 'size_type' does not name a type; did you mean 'size_t'?
  578 | constexpr size_type capacity() const noexcept;
      |           ^~~~~~~~~
      |           size_t
p808.cpp:580:16: error: variable or field 'reserve' declared void
  580 | constexpr void reserve(size_type res_arg);
      |                ^~~~~~~
p808.cpp:580:24: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  580 | constexpr void reserve(size_type res_arg);
      |                        ^~~~~~~~~
      |                        size_t
p808.cpp:591:44: error: non-member function 'constexpr bool empty()' cannot have cv-qualifier
  591 | [[nodiscard]] constexpr bool empty() const noexcept;
      |                                            ^~~~~~~~
p808.cpp:594:11: error: 'const_reference' does not name a type
  594 | constexpr const_reference operator[](size_type pos) const;
      |           ^~~~~~~~~~~~~~~
p808.cpp:595:11: error: 'reference' does not name a type
  595 | constexpr reference       operator[](size_type pos);
      |           ^~~~~~~~~
p808.cpp:599:11: error: 'const_reference' does not name a type
  599 | constexpr const_reference at(size_type pos) const;
      |           ^~~~~~~~~~~~~~~
p808.cpp:600:11: error: 'reference' does not name a type
  600 | constexpr reference       at(size_type pos);
      |           ^~~~~~~~~
p808.cpp:603:17: error: 'charT' does not name a type; did you mean 'char'?
  603 | constexpr const charT& front() const;
      |                 ^~~~~
      |                 char
p808.cpp:604:11: error: 'charT' does not name a type; did you mean 'char'?
  604 | constexpr charT& front();
      |           ^~~~~
      |           char
p808.cpp:607:17: error: 'charT' does not name a type; did you mean 'char'?
  607 | constexpr const charT& back() const;
      |                 ^~~~~
      |                 char
p808.cpp:608:11: error: 'charT' does not name a type; did you mean 'char'?
  608 | constexpr charT& back();
      |           ^~~~~
      |           char
p808.cpp:613:11: error: reference to 'basic_string' is ambiguous
  613 | constexpr basic_string& operator+=(const basic_string& str);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:615:1: error: expected unqualified-id before 'return'
  615 | return append(str);
      | ^~~~~~
p808.cpp:617:11: error: reference to 'basic_string' is ambiguous
  617 | constexpr basic_string& operator+=(const T& t);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:620:19: error: 'charT' was not declared in this scope; did you mean 'char'?
  620 | basic_string_view<charT, traits> sv = t;
      |                   ^~~~~
      |                   char
p808.cpp:620:26: error: 'traits' was not declared in this scope
  620 | basic_string_view<charT, traits> sv = t;
      |                          ^~~~~~
p808.cpp:620:32: error: template argument 1 is invalid
  620 | basic_string_view<charT, traits> sv = t;
      |                                ^
p808.cpp:620:32: error: template argument 2 is invalid
p808.cpp:620:39: error: 't' was not declared in this scope; did you mean 'tm'?
  620 | basic_string_view<charT, traits> sv = t;
      |                                       ^
      |                                       tm
p808.cpp:621:8: error: expected unqualified-id before 'return'
  621 |        return append(sv);
      |        ^~~~~~
p808.cpp:622:11: error: reference to 'basic_string' is ambiguous
  622 | constexpr basic_string& operator+=(const charT* s);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:624:1: error: expected unqualified-id before 'return'
  624 | return append(s); constexpr basic_string& operator+=(charT c);
      | ^~~~~~
p808.cpp:624:29: error: reference to 'basic_string' is ambiguous
  624 | return append(s); constexpr basic_string& operator+=(charT c);
      |                             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:626:1: error: expected unqualified-id before 'return'
  626 | return append(size_type{1}, c);
      | ^~~~~~
p808.cpp:626:27: error: expected unqualified-id before ',' token
  626 | return append(size_type{1}, c);
      |                           ^
p808.cpp:626:30: error: expected constructor, destructor, or type conversion before ')' token
  626 | return append(size_type{1}, c);
      |                              ^
p808.cpp:627:11: error: reference to 'basic_string' is ambiguous
  627 | constexpr basic_string& operator+=(initializer_list<charT> il);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:630:11: error: reference to 'basic_string' is ambiguous
  630 | constexpr basic_string& append(const basic_string& str);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:632:1: error: expected unqualified-id before 'return'
  632 | return append(str.data(), str.size());
      | ^~~~~~
p808.cpp:633:11: error: reference to 'basic_string' is ambiguous
  633 | constexpr basic_string& append(const basic_string& str, size_type pos, size_type n = npos);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:635:1: error: expected unqualified-id before 'return'
  635 | return append(basic_string_view<charT, traits>(str).substr(pos, n));
      | ^~~~~~
p808.cpp:637:13: error: reference to 'basic_string' is ambiguous
  637 |   constexpr basic_string& append(const T& t);
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:641:19: error: 'charT' was not declared in this scope; did you mean 'char'?
  641 | basic_string_view<charT, traits> sv = t;
      |                   ^~~~~
      |                   char
p808.cpp:641:26: error: 'traits' was not declared in this scope
  641 | basic_string_view<charT, traits> sv = t;
      |                          ^~~~~~
p808.cpp:641:32: error: template argument 1 is invalid
  641 | basic_string_view<charT, traits> sv = t;
      |                                ^
p808.cpp:641:32: error: template argument 2 is invalid
p808.cpp:641:34: error: redefinition of 'int sv'
  641 | basic_string_view<charT, traits> sv = t;
      |                                  ^~
p808.cpp:620:34: note: 'int sv' previously defined here
  620 | basic_string_view<charT, traits> sv = t;
      |                                  ^~
p808.cpp:641:39: error: 't' was not declared in this scope; did you mean 'tm'?
  641 | basic_string_view<charT, traits> sv = t;
      |                                       ^
      |                                       tm
p808.cpp:642:3: error: expected unqualified-id before 'return'
  642 |   return append(sv.data(), sv.size());
      |   ^~~~~~
p808.cpp:644:13: error: reference to 'basic_string' is ambiguous
  644 |   constexpr basic_string& append(const T& t, size_type pos, size_type n = npos);
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:648:19: error: 'charT' was not declared in this scope; did you mean 'char'?
  648 | basic_string_view<charT, traits> sv = t;
      |                   ^~~~~
      |                   char
p808.cpp:648:26: error: 'traits' was not declared in this scope
  648 | basic_string_view<charT, traits> sv = t;
      |                          ^~~~~~
p808.cpp:648:32: error: template argument 1 is invalid
  648 | basic_string_view<charT, traits> sv = t;
      |                                ^
p808.cpp:648:32: error: template argument 2 is invalid
p808.cpp:648:34: error: redefinition of 'int sv'
  648 | basic_string_view<charT, traits> sv = t;
      |                                  ^~
p808.cpp:620:34: note: 'int sv' previously defined here
  620 | basic_string_view<charT, traits> sv = t;
      |                                  ^~
p808.cpp:648:39: error: 't' was not declared in this scope; did you mean 'tm'?
  648 | basic_string_view<charT, traits> sv = t;
      |                                       ^
      |                                       tm
p808.cpp:649:3: error: expected unqualified-id before 'return'
  649 |   return append(sv.substr(pos, n));
      |   ^~~~~~
p808.cpp:650:11: error: reference to 'basic_string' is ambiguous
  650 | constexpr basic_string& append(const charT* s, size_type n);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:653:11: error: reference to 'basic_string' is ambiguous
  653 | constexpr basic_string& append(const charT* s);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:655:1: error: expected unqualified-id before 'return'
  655 | return append(s, traits::length(s));
      | ^~~~~~
p808.cpp:656:11: error: reference to 'basic_string' is ambiguous
  656 | constexpr basic_string& append(size_type n, charT c);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:659:13: error: reference to 'basic_string' is ambiguous
  659 |   constexpr basic_string& append(InputIterator first, InputIterator last);
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:660:12: error: found ':' in nested-name-specifier, expected '::'
  660 | Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
      |            ^
      |            ::
p808.cpp:660:1: error: 'Constraints' does not name a type
  660 | Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
      | ^~~~~~~~~~~
p808.cpp:663:10: error: 'container' has not been declared
  663 | template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
      |          ^~~~~~~~~
p808.cpp:663:19: error: expected '>' before '-' token
  663 | template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
      |                   ^
p808.cpp:663:57: error: reference to 'basic_string' is ambiguous
  663 | template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
      |                                                         ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:665:1: error: expected unqualified-id before 'return'
  665 | return append(basic_string(from_range, std::forward<R>(rg), get_- allocator()));
      | ^~~~~~
p808.cpp:666:11: error: reference to 'basic_string' is ambiguous
  666 | constexpr basic_string& append(initializer_list<charT> il);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:668:1: error: expected unqualified-id before 'return'
  668 | return append(il.begin(), il.size());
      | ^~~~~~
p808.cpp:669:21: error: variable or field 'push_back' declared void
  669 |      constexpr void push_back(charT c);
      |                     ^~~~~~~~~
p808.cpp:669:31: error: 'charT' was not declared in this scope; did you mean 'char'?
  669 |      constexpr void push_back(charT c);
      |                               ^~~~~
      |                               char
p808.cpp:672:11: error: reference to 'basic_string' is ambiguous
  672 | constexpr basic_string& assign(const basic_string& str);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:674:1: error: expected unqualified-id before 'return'
  674 | return *this = str;
      | ^~~~~~
p808.cpp:675:11: error: reference to 'basic_string' is ambiguous
  675 | constexpr basic_string& assign(basic_string&& str)
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:679:1: error: expected unqualified-id before 'return'
  679 | return *this = std::move(str);
      | ^~~~~~
p808.cpp:680:11: error: reference to 'basic_string' is ambiguous
  680 | constexpr basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:682:1: error: expected unqualified-id before 'return'
  682 | return assign(basic_string_view<charT, traits>(str).substr(pos, n));
      | ^~~~~~
p808.cpp:684:13: error: reference to 'basic_string' is ambiguous
  684 |   constexpr basic_string& assign(const T& t);
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:687:19: error: 'charT' was not declared in this scope; did you mean 'char'?
  687 | basic_string_view<charT, traits> sv = t;
      |                   ^~~~~
      |                   char
p808.cpp:687:26: error: 'traits' was not declared in this scope
  687 | basic_string_view<charT, traits> sv = t;
      |                          ^~~~~~
p808.cpp:687:32: error: template argument 1 is invalid
  687 | basic_string_view<charT, traits> sv = t;
      |                                ^
p808.cpp:687:32: error: template argument 2 is invalid
p808.cpp:687:34: error: redefinition of 'int sv'
  687 | basic_string_view<charT, traits> sv = t;
      |                                  ^~
p808.cpp:620:34: note: 'int sv' previously defined here
  620 | basic_string_view<charT, traits> sv = t;
      |                                  ^~
p808.cpp:687:39: error: 't' was not declared in this scope; did you mean 'tm'?
  687 | basic_string_view<charT, traits> sv = t;
      |                                       ^
      |                                       tm
p808.cpp:688:3: error: expected unqualified-id before 'return'
  688 |   return assign(sv.data(), sv.size());
      |   ^~~~~~
p808.cpp:690:13: error: reference to 'basic_string' is ambiguous
  690 |   constexpr basic_string& assign(const T& t, size_type pos, size_type n = npos);
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:693:19: error: 'charT' was not declared in this scope; did you mean 'char'?
  693 | basic_string_view<charT, traits> sv = t;
      |                   ^~~~~
      |                   char
p808.cpp:693:26: error: 'traits' was not declared in this scope
  693 | basic_string_view<charT, traits> sv = t;
      |                          ^~~~~~
p808.cpp:693:32: error: template argument 1 is invalid
  693 | basic_string_view<charT, traits> sv = t;
      |                                ^
p808.cpp:693:32: error: template argument 2 is invalid
p808.cpp:693:34: error: redefinition of 'int sv'
  693 | basic_string_view<charT, traits> sv = t;
      |                                  ^~
p808.cpp:620:34: note: 'int sv' previously defined here
  620 | basic_string_view<charT, traits> sv = t;
      |                                  ^~
p808.cpp:693:39: error: 't' was not declared in this scope; did you mean 'tm'?
  693 | basic_string_view<charT, traits> sv = t;
      |                                       ^
      |                                       tm
p808.cpp:694:3: error: expected unqualified-id before 'return'
  694 |   return assign(sv.substr(pos, n));
      |   ^~~~~~
p808.cpp:695:11: error: reference to 'basic_string' is ambiguous
  695 | constexpr basic_string& assign(const charT* s, size_type n);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:698:11: error: reference to 'basic_string' is ambiguous
  698 | constexpr basic_string& assign(const charT* s);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:700:1: error: expected unqualified-id before 'return'
  700 | return assign(s, traits::length(s)); constexpr basic_string& assign(initializer_list<charT> il);
      | ^~~~~~
p808.cpp:700:48: error: reference to 'basic_string' is ambiguous
  700 | return assign(s, traits::length(s)); constexpr basic_string& assign(initializer_list<charT> il);
      |                                                ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:702:1: error: expected unqualified-id before 'return'
  702 | return assign(il.begin(), il.size());
      | ^~~~~~
p808.cpp:703:11: error: reference to 'basic_string' is ambiguous
  703 | constexpr basic_string& assign(size_type n, charT c);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:705:10: error: expected constructor, destructor, or type conversion before ';' token
  705 |   clear();
      |          ^
p808.cpp:706:9: error: expected constructor, destructor, or type conversion before '(' token
  706 |   resize(n, c);
      |         ^
p808.cpp:707:3: error: expected unqualified-id before 'return'
  707 |   return *this;
      |   ^~~~~~
p808.cpp:709:13: error: reference to 'basic_string' is ambiguous
  709 |   constexpr basic_string& assign(InputIterator first, InputIterator last);
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:712:1: error: expected unqualified-id before 'return'
  712 | return assign(basic_string(first, last, get_allocator())); template<container-compatible-range<charT> R>
      | ^~~~~~
p808.cpp:712:69: error: 'container' has not been declared
  712 | return assign(basic_string(first, last, get_allocator())); template<container-compatible-range<charT> R>
      |                                                                     ^~~~~~~~~
p808.cpp:712:78: error: expected '>' before '-' token
  712 | return assign(basic_string(first, last, get_allocator())); template<container-compatible-range<charT> R>
      |                                                                              ^
p808.cpp:713:11: error: reference to 'basic_string' is ambiguous
  713 | constexpr basic_string& assign_range(R&& rg);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:715:1: error: expected unqualified-id before 'return'
  715 | return assign(basic_string(from_range, std::forward<R>(rg), get_- allocator()));
      | ^~~~~~
p808.cpp:717:11: error: reference to 'basic_string' is ambiguous
  717 | constexpr basic_string& insert(size_type pos, const basic_string& str);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:719:1: error: expected unqualified-id before 'return'
  719 | return insert(pos, str.data(), str.size());
      | ^~~~~~
p808.cpp:720:11: error: reference to 'basic_string' is ambiguous
  720 | constexpr basic_string& insert(size_type pos1, const basic_string& str,
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:723:1: error: expected unqualified-id before 'return'
  723 | return insert(pos1, basic_string_view<charT, traits>(str), pos2, n);
      | ^~~~~~
p808.cpp:725:13: error: reference to 'basic_string' is ambiguous
  725 |   constexpr basic_string& insert(size_type pos, const T& t);
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:728:3: error: expected unqualified-id before 'return'
  728 |   return insert(pos, sv.data(), sv.size());
      |   ^~~~~~
p808.cpp:730:13: error: reference to 'basic_string' is ambiguous
  730 |   constexpr basic_string& insert(size_type pos1, const T& t,
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:734:3: error: expected unqualified-id before 'return'
  734 |   return insert(pos1, sv.substr(pos2, n));
      |   ^~~~~~
p808.cpp:735:11: error: reference to 'basic_string' is ambiguous
  735 | constexpr basic_string& insert(size_type pos, const charT* s, size_type n);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:741:11: error: reference to 'basic_string' is ambiguous
  741 | constexpr basic_string& insert(size_type pos, const charT* s);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:743:11: error: reference to 'basic_string' is ambiguous
  743 | constexpr basic_string& insert(size_type pos, size_type n, charT c);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:749:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  749 | constexpr iterator insert(const_iterator p, charT c);
      |           ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p808.cpp:749:27: error: 'const_iterator' was not declared in this scope
  749 | constexpr iterator insert(const_iterator p, charT c);
      |                           ^~~~~~~~~~~~~~
p808.cpp:749:45: error: 'charT' was not declared in this scope; did you mean 'char'?
  749 | constexpr iterator insert(const_iterator p, charT c);
      |                                             ^~~~~
      |                                             char
p808.cpp:753:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  753 | constexpr iterator insert(const_iterator p, size_type n, charT c);
      |           ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p808.cpp:753:27: error: 'const_iterator' was not declared in this scope
  753 | constexpr iterator insert(const_iterator p, size_type n, charT c);
      |                           ^~~~~~~~~~~~~~
p808.cpp:753:45: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  753 | constexpr iterator insert(const_iterator p, size_type n, charT c);
      |                                             ^~~~~~~~~
      |                                             size_t
p808.cpp:753:58: error: 'charT' was not declared in this scope; did you mean 'char'?
  753 | constexpr iterator insert(const_iterator p, size_type n, charT c);
      |                                                          ^~~~~
      |                                                          char
p808.cpp:758:13: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  758 |   constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
      |             ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p808.cpp:758:29: error: 'const_iterator' was not declared in this scope
  758 |   constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
      |                             ^~~~~~~~~~~~~~
p808.cpp:758:61: error: expected primary-expression before 'first'
  758 |   constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
      |                                                             ^~~~~
p808.cpp:758:82: error: expected primary-expression before 'last'
  758 |   constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
      |                                                                                  ^~~~
p808.cpp:762:10: error: 'container' has not been declared
  762 | template<container-compatible-range<charT> R>
      |          ^~~~~~~~~
p808.cpp:762:19: error: expected '>' before '-' token
  762 | template<container-compatible-range<charT> R>
      |                   ^
p808.cpp:763:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  763 | constexpr iterator insert_range(const_iterator p, R&& rg);
      |           ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p808.cpp:763:33: error: 'const_iterator' was not declared in this scope
  763 | constexpr iterator insert_range(const_iterator p, R&& rg);
      |                                 ^~~~~~~~~~~~~~
p808.cpp:763:51: error: 'R' was not declared in this scope
  763 | constexpr iterator insert_range(const_iterator p, R&& rg);
      |                                                   ^
p808.cpp:763:55: error: 'rg' was not declared in this scope
  763 | constexpr iterator insert_range(const_iterator p, R&& rg);
      |                                                       ^~
p808.cpp:767:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  767 | constexpr iterator insert(const_iterator p, initializer_list<charT> il);
      |           ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p808.cpp:767:27: error: 'const_iterator' was not declared in this scope
  767 | constexpr iterator insert(const_iterator p, initializer_list<charT> il);
      |                           ^~~~~~~~~~~~~~
p808.cpp:767:62: error: 'charT' was not declared in this scope; did you mean 'char'?
  767 | constexpr iterator insert(const_iterator p, initializer_list<charT> il);
      |                                                              ^~~~~
      |                                                              char
p808.cpp:767:67: error: template argument 1 is invalid
  767 | constexpr iterator insert(const_iterator p, initializer_list<charT> il);
      |                                                                   ^
p808.cpp:770:11: error: reference to 'basic_string' is ambiguous
  770 | constexpr basic_string& erase(size_type pos = 0, size_type n = npos);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:774:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  774 | constexpr iterator erase(const_iterator p);
      |           ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p808.cpp:774:26: error: 'const_iterator' was not declared in this scope
  774 | constexpr iterator erase(const_iterator p);
      |                          ^~~~~~~~~~~~~~
p808.cpp:778:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  778 | constexpr iterator erase(const_iterator first, const_iterator last);
      |           ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p808.cpp:778:26: error: 'const_iterator' was not declared in this scope
  778 | constexpr iterator erase(const_iterator first, const_iterator last);
      |                          ^~~~~~~~~~~~~~
p808.cpp:778:48: error: 'const_iterator' was not declared in this scope
  778 | constexpr iterator erase(const_iterator first, const_iterator last);
      |                                                ^~~~~~~~~~~~~~
p808.cpp:787:11: error: reference to 'basic_string' is ambiguous
  787 | constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:789:1: error: expected unqualified-id before 'return'
  789 | return replace(pos1, n1, str.data(), str.size()); constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
      | ^~~~~~
p808.cpp:789:61: error: reference to 'basic_string' is ambiguous
  789 | return replace(pos1, n1, str.data(), str.size()); constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
      |                                                             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:792:1: error: expected unqualified-id before 'return'
  792 | return replace(pos1, n1, basic_string_view<charT, traits>(str).substr(pos2, n2));
      | ^~~~~~
p808.cpp:794:13: error: reference to 'basic_string' is ambiguous
  794 |   constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:797:3: error: expected unqualified-id before 'return'
  797 |   return replace(pos1, n1, sv.data(), sv.size());
      |   ^~~~~~
p808.cpp:799:13: error: reference to 'basic_string' is ambiguous
  799 |   constexpr basic_string& replace(size_type pos1, size_type n1, const T& t,
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:803:19: error: 'charT' was not declared in this scope; did you mean 'char'?
  803 | basic_string_view<charT, traits> sv = t;
      |                   ^~~~~
      |                   char
p808.cpp:803:26: error: 'traits' was not declared in this scope
  803 | basic_string_view<charT, traits> sv = t;
      |                          ^~~~~~
p808.cpp:803:32: error: template argument 1 is invalid
  803 | basic_string_view<charT, traits> sv = t;
      |                                ^
p808.cpp:803:32: error: template argument 2 is invalid
p808.cpp:803:34: error: redefinition of 'int sv'
  803 | basic_string_view<charT, traits> sv = t;
      |                                  ^~
p808.cpp:620:34: note: 'int sv' previously defined here
  620 | basic_string_view<charT, traits> sv = t;
      |                                  ^~
p808.cpp:803:39: error: 't' was not declared in this scope; did you mean 'tm'?
  803 | basic_string_view<charT, traits> sv = t;
      |                                       ^
      |                                       tm
p808.cpp:804:3: error: expected unqualified-id before 'return'
  804 |   return replace(pos1, n1, sv.substr(pos2, n2));
      |   ^~~~~~
p808.cpp:805:11: error: reference to 'basic_string' is ambiguous
  805 | constexpr basic_string& replace(size_type pos1, size_type n1, const charT* s, size_type n2);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:810:11: error: reference to 'basic_string' is ambiguous
  810 | constexpr basic_string& replace(size_type pos, size_type n, const charT* s);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:816:11: error: reference to 'basic_string' is ambiguous
  816 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:818:11: error: reference to 'basic_string' is ambiguous
  818 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:822:24: error: 'charT' was not declared in this scope; did you mean 'char'?
  822 |      basic_string_view<charT, traits> sv = t;
      |                        ^~~~~
      |                        char
p808.cpp:822:31: error: 'traits' was not declared in this scope
  822 |      basic_string_view<charT, traits> sv = t;
      |                               ^~~~~~
p808.cpp:822:37: error: template argument 1 is invalid
  822 |      basic_string_view<charT, traits> sv = t;
      |                                     ^
p808.cpp:822:37: error: template argument 2 is invalid
p808.cpp:822:39: error: redefinition of 'int sv'
  822 |      basic_string_view<charT, traits> sv = t;
      |                                       ^~
p808.cpp:620:34: note: 'int sv' previously defined here
  620 | basic_string_view<charT, traits> sv = t;
      |                                  ^~
p808.cpp:822:44: error: 't' was not declared in this scope; did you mean 'tm'?
  822 |      basic_string_view<charT, traits> sv = t;
      |                                            ^
      |                                            tm
p808.cpp:823:6: error: expected unqualified-id before 'return'
  823 |      return replace(i1 - begin(), i2 - i1, sv.data(), sv.size());
      |      ^~~~~~
p808.cpp:824:11: error: reference to 'basic_string' is ambiguous
  824 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:827:11: error: reference to 'basic_string' is ambiguous
  827 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:831:13: error: reference to 'basic_string' is ambiguous
  831 |   constexpr basic_string& replace(const_iterator i1, const_iterator i2,
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:835:10: error: 'container' has not been declared
  835 | template<container-compatible-range<charT> R>
      |          ^~~~~~~~~
p808.cpp:835:19: error: expected '>' before '-' token
  835 | template<container-compatible-range<charT> R>
      |                   ^
p808.cpp:836:11: error: reference to 'basic_string' is ambiguous
  836 | constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:838:1: error: expected unqualified-id before 'return'
  838 | return replace(i1, i2, basic_string(from_range, std::forward<R>(rg), get_allocator()));
      | ^~~~~~
p808.cpp:839:11: error: reference to 'basic_string' is ambiguous
  839 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il);
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:842:11: error: 'size_type' does not name a type; did you mean 'size_t'?
  842 | constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
      |           ^~~~~~~~~
      |           size_t
p808.cpp:844:1: error: expected unqualified-id before 'return'
  844 | return basic_string_view<charT, traits>(*this).copy(s, n, pos);
      | ^~~~~~
p808.cpp:847:16: error: variable or field 'swap' declared void
  847 | constexpr void swap(basic_string& s)
      |                ^~~~
p808.cpp:847:21: error: reference to 'basic_string' is ambiguous
  847 | constexpr void swap(basic_string& s)
      |                     ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:847:35: error: 's' was not declared in this scope; did you mean 'sv'?
  847 | constexpr void swap(basic_string& s)
      |                                   ^
      |                                   sv
p808.cpp:852:11: error: 'size_type' does not name a type; did you mean 'size_t'?
  852 | constexpr size_type F(const basic_string& str, size_type pos) const noexcept;
      |           ^~~~~~~~~
      |           size_t
p808.cpp:854:1: error: expected unqualified-id before 'return'
  854 | return F (basic_string_view<charT, traits>(str), pos);
      | ^~~~~~
p808.cpp:856:11: error: 'size_type' does not name a type; did you mean 'size_t'?
  856 | constexpr size_type F(const charT* s, size_type pos) const;
      |           ^~~~~~~~~
      |           size_t
p808.cpp:858:1: error: expected unqualified-id before 'return'
  858 | return F (basic_string_view<charT, traits>(s), pos);
      | ^~~~~~
p808.cpp:860:11: error: 'size_type' does not name a type; did you mean 'size_t'?
  860 | constexpr size_type F(const charT* s, size_type pos, size_type n) const;
      |           ^~~~~~~~~
      |           size_t
p808.cpp:863:11: error: 'size_type' does not name a type; did you mean 'size_t'?
  863 | constexpr size_type F(charT c, size_type pos) const noexcept; has effects equivalent to:
      |           ^~~~~~~~~
      |           size_t
p808.cpp:863:63: error: 'has' does not name a type
  863 | constexpr size_type F(charT c, size_type pos) const noexcept; has effects equivalent to:
      |                                                               ^~~
p808.cpp:866:11: error: 'size_type' does not name a type; did you mean 'size_t'?
  866 | constexpr size_type find(const T& t, size_type pos = 0) const noexcept(see below);
      |           ^~~~~~~~~
      |           size_t
p808.cpp:868:11: error: 'size_type' does not name a type; did you mean 'size_t'?
  868 | constexpr size_type rfind(const T& t, size_type pos = npos) const noexcept(see_below);
      |           ^~~~~~~~~
      |           size_t
p808.cpp:870:11: error: 'size_type' does not name a type; did you mean 'size_t'?
  870 | constexpr size_type find_first_of(const T& t, size_type pos = 0) const noexcept(see_below);
      |           ^~~~~~~~~
      |           size_t
p808.cpp:872:11: error: 'size_type' does not name a type; did you mean 'size_t'?
  872 | constexpr size_type find_last_of(const T& t, size_type pos = npos) const noexcept(see_below);
      |           ^~~~~~~~~
      |           size_t
p808.cpp:874:11: error: 'size_type' does not name a type; did you mean 'size_t'?
  874 | constexpr size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept(see_below);
      |           ^~~~~~~~~
      |           size_t
p808.cpp:880:17: error: 'charT' does not name a type; did you mean 'char'?
  880 | constexpr const charT* c_str() const noexcept;
      |                 ^~~~~
      |                 char
p808.cpp:881:17: error: 'charT' does not name a type; did you mean 'char'?
  881 | constexpr const charT* data() const noexcept;
      |                 ^~~~~
      |                 char
p808.cpp:884:11: error: 'charT' does not name a type; did you mean 'char'?
  884 | constexpr charT* data() noexcept;
      |           ^~~~~
      |           char
p808.cpp:887:38: error: 'charT' was not declared in this scope; did you mean 'char'?
  887 | constexpr operator basic_string_view<charT, traits>() const noexcept;
      |                                      ^~~~~
      |                                      char
p808.cpp:887:45: error: 'traits' was not declared in this scope
  887 | constexpr operator basic_string_view<charT, traits>() const noexcept;
      |                                             ^~~~~~
p808.cpp:887:51: error: template argument 1 is invalid
  887 | constexpr operator basic_string_view<charT, traits>() const noexcept;
      |                                                   ^
p808.cpp:887:51: error: template argument 2 is invalid
p808.cpp:892:11: error: 'size_type' does not name a type; did you mean 'size_t'?
  892 | constexpr size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept(see below);
      |           ^~~~~~~~~
      |           size_t
p808.cpp:895:1: error: expected unqualified-id before 'return'
  895 | return s.G(sv, pos);
      | ^~~~~~
p808.cpp:898:11: error: reference to 'basic_string' is ambiguous
  898 | constexpr basic_string substr(size_type pos = 0, size_type n = npos) const;
      |           ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:902:29: error: 'T' does not name a type
  902 | constexpr int compare(const T& t) const noexcept(see_below);
      |                             ^
p808.cpp:902:50: error: 'see_below' was not declared in this scope
  902 | constexpr int compare(const T& t) const noexcept(see_below);
      |                                                  ^~~~~~~~~
p808.cpp:902:59: error: non-member function 'constexpr int compare(const int&)' cannot have cv-qualifier
  902 | constexpr int compare(const T& t) const noexcept(see_below);
      |                                                           ^
p808.cpp:908:25: error: 'template<class T> constexpr const int compare' redeclared as different kind of entity
  908 |   constexpr int compare(size_type pos1, size_type n1, const T& t) const;
      |                         ^~~~~~~~~
p808.cpp:902:15: note: previous declaration 'constexpr int compare(const int&)'
  902 | constexpr int compare(const T& t) const noexcept(see_below);
      |               ^~~~~~~
p808.cpp:908:25: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  908 |   constexpr int compare(size_type pos1, size_type n1, const T& t) const;
      |                         ^~~~~~~~~
      |                         size_t
p808.cpp:908:41: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  908 |   constexpr int compare(size_type pos1, size_type n1, const T& t) const;
      |                                         ^~~~~~~~~
      |                                         size_t
p808.cpp:908:55: error: expected primary-expression before 'const'
  908 |   constexpr int compare(size_type pos1, size_type n1, const T& t) const;
      |                                                       ^~~~~
p808.cpp:911:1: error: expected unqualified-id before 'return'
  911 | return basic_string_view<charT, traits>(*this).substr(pos1, n1).compare(t);
      | ^~~~~~
p808.cpp:913:25: error: 'template<class T> constexpr const int compare' redeclared as different kind of entity
  913 |   constexpr int compare(size_type pos1, size_type n1, const T& t,
      |                         ^~~~~~~~~
p808.cpp:902:15: note: previous declaration 'constexpr int compare(const int&)'
  902 | constexpr int compare(const T& t) const noexcept(see_below);
      |               ^~~~~~~
p808.cpp:913:25: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  913 |   constexpr int compare(size_type pos1, size_type n1, const T& t,
      |                         ^~~~~~~~~
      |                         size_t
p808.cpp:913:41: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  913 |   constexpr int compare(size_type pos1, size_type n1, const T& t,
      |                                         ^~~~~~~~~
      |                                         size_t
p808.cpp:913:55: error: expected primary-expression before 'const'
  913 |   constexpr int compare(size_type pos1, size_type n1, const T& t,
      |                                                       ^~~~~
p808.cpp:914:20: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  914 |                    size_type pos2, size_type n2 = npos) const;
      |                    ^~~~~~~~~
      |                    size_t
p808.cpp:914:36: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  914 |                    size_type pos2, size_type n2 = npos) const;
      |                                    ^~~~~~~~~
      |                                    size_t
p808.cpp:917:19: error: 'charT' was not declared in this scope; did you mean 'char'?
  917 | basic_string_view<charT, traits> s = *this, sv = t;
      |                   ^~~~~
      |                   char
p808.cpp:917:26: error: 'traits' was not declared in this scope
  917 | basic_string_view<charT, traits> s = *this, sv = t;
      |                          ^~~~~~
p808.cpp:917:32: error: template argument 1 is invalid
  917 | basic_string_view<charT, traits> s = *this, sv = t;
      |                                ^
p808.cpp:917:32: error: template argument 2 is invalid
p808.cpp:917:39: error: invalid use of 'this' at top level
  917 | basic_string_view<charT, traits> s = *this, sv = t;
      |                                       ^~~~
p808.cpp:918:8: error: expected unqualified-id before 'return'
  918 |        return s.substr(pos1, n1).compare(sv.substr(pos2, n2));
      |        ^~~~~~
p808.cpp:919:29: error: reference to 'basic_string' is ambiguous
  919 | constexpr int compare(const basic_string& str) const noexcept;
      |                             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:919:54: error: non-member function 'constexpr int compare(const int&)' cannot have cv-qualifier
  919 | constexpr int compare(const basic_string& str) const noexcept;
      |                                                      ^~~~~~~~
p808.cpp:919:15: error: declaration of 'constexpr int compare(const int&) noexcept' has a different exception specifier
  919 | constexpr int compare(const basic_string& str) const noexcept;
      |               ^~~~~~~
p808.cpp:902:15: note: from previous declaration 'constexpr int compare(const int&)'
  902 | constexpr int compare(const T& t) const noexcept(see_below);
      |               ^~~~~~~
p808.cpp:922:34: error: 'charT' was not declared in this scope; did you mean 'char'?
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                  ^~~~~
      |                                  char
p808.cpp:922:41: error: 'traits' was not declared in this scope
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                         ^~~~~~
p808.cpp:922:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                                 ^~~~~~~~~
      |                                                 alloca
p808.cpp:922:34: error: 'charT' was not declared in this scope; did you mean 'char'?
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                  ^~~~~
      |                                  char
p808.cpp:922:41: error: 'traits' was not declared in this scope
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                         ^~~~~~
p808.cpp:922:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                                 ^~~~~~~~~
      |                                                 alloca
p808.cpp:922:34: error: 'charT' was not declared in this scope; did you mean 'char'?
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                  ^~~~~
      |                                  char
p808.cpp:922:41: error: 'traits' was not declared in this scope
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                         ^~~~~~
p808.cpp:922:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                                 ^~~~~~~~~
      |                                                 alloca
p808.cpp:922:34: error: 'charT' was not declared in this scope; did you mean 'char'?
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                  ^~~~~
      |                                  char
p808.cpp:922:41: error: 'traits' was not declared in this scope
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                         ^~~~~~
p808.cpp:922:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                                 ^~~~~~~~~
      |                                                 alloca
p808.cpp:922:34: error: 'charT' was not declared in this scope; did you mean 'char'?
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                  ^~~~~
      |                                  char
p808.cpp:922:41: error: 'traits' was not declared in this scope
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                         ^~~~~~
p808.cpp:922:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                                 ^~~~~~~~~
      |                                                 alloca
p808.cpp:922:34: error: 'charT' was not declared in this scope; did you mean 'char'?
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                  ^~~~~
      |                                  char
p808.cpp:922:41: error: 'traits' was not declared in this scope
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                         ^~~~~~
p808.cpp:922:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                                 ^~~~~~~~~
      |                                                 alloca
p808.cpp:922:21: error: reference to 'basic_string' is ambiguous
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                     ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:922:33: error: expected ',' or '...' before '<' token
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                 ^
p808.cpp:922:83: error: expected constructor, destructor, or type conversion before ';' token
  922 |     operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |                                                                                   ^
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                     ^~~~~
      |                     char
p808.cpp:924:28: error: 'traits' was not declared in this scope
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                            ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                                    ^~~~~~~~~
      |                                    alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                     ^~~~~
      |                     char
p808.cpp:924:28: error: 'traits' was not declared in this scope
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                            ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                                    ^~~~~~~~~
      |                                    alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                     ^~~~~
      |                     char
p808.cpp:924:28: error: 'traits' was not declared in this scope
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                            ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                                    ^~~~~~~~~
      |                                    alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                     ^~~~~
      |                     char
p808.cpp:924:28: error: 'traits' was not declared in this scope
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                            ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                                    ^~~~~~~~~
      |                                    alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                     ^~~~~
      |                     char
p808.cpp:924:28: error: 'traits' was not declared in this scope
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                            ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                                    ^~~~~~~~~
      |                                    alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                     ^~~~~
      |                     char
p808.cpp:924:28: error: 'traits' was not declared in this scope
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                            ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                                    ^~~~~~~~~
      |                                    alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                     ^~~~~
      |                     char
p808.cpp:924:28: error: 'traits' was not declared in this scope
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                            ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                                    ^~~~~~~~~
      |                                    alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                     ^~~~~
      |                     char
p808.cpp:924:28: error: 'traits' was not declared in this scope
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                            ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                                    ^~~~~~~~~
      |                                    alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                     ^~~~~
      |                     char
p808.cpp:924:28: error: 'traits' was not declared in this scope
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                            ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |                                    ^~~~~~~~~
      |                                    alloca
p808.cpp:924:8: error: reference to 'basic_string' is ambiguous
  924 |        basic_string<charT, traits, Allocator> r = lhs;
      |        ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:925:8: error: 'r' does not name a type
  925 |        r.append(rhs);
      |        ^
p808.cpp:926:8: error: expected unqualified-id before 'return'
  926 |        return r;
      |        ^~~~~~
p808.cpp:928:13: error: reference to 'basic_string' is ambiguous
  928 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:931:26: error: 'constexpr const int compare' redeclared as different kind of entity
  931 |    constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
      |                          ^~~~~~~~~
p808.cpp:919:15: note: previous declaration 'constexpr int compare(const int&)'
  919 | constexpr int compare(const basic_string& str) const noexcept;
      |               ^~~~~~~
p808.cpp:931:26: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  931 |    constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
      |                          ^~~~~~~~~
      |                          size_t
p808.cpp:931:42: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  931 |    constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
      |                                          ^~~~~~~~~
      |                                          size_t
p808.cpp:931:56: error: expected primary-expression before 'const'
  931 |    constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
      |                                                        ^~~~~
p808.cpp:932:26: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  932 |                          size_type pos2, size_type n2 = npos) const;
      |                          ^~~~~~~~~
      |                          size_t
p808.cpp:932:42: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  932 |                          size_type pos2, size_type n2 = npos) const;
      |                                          ^~~~~~~~~
      |                                          size_t
p808.cpp:934:1: error: expected unqualified-id before 'return'
  934 | return compare(pos1, n1, basic_string_view<charT, traits>(str), pos2, n2);
      | ^~~~~~
p808.cpp:935:29: error: 'charT' does not name a type; did you mean 'char'?
  935 | constexpr int compare(const charT* s) const;
      |                             ^~~~~
      |                             char
p808.cpp:935:39: error: non-member function 'constexpr int compare(const int*)' cannot have cv-qualifier
  935 | constexpr int compare(const charT* s) const;
      |                                       ^~~~~
p808.cpp:938:23: error: 'constexpr const int compare' redeclared as different kind of entity
  938 | constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
      |                       ^~~~~~~~~
p808.cpp:935:15: note: previous declaration 'constexpr int compare(const int*)'
  935 | constexpr int compare(const charT* s) const;
      |               ^~~~~~~
p808.cpp:938:23: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  938 | constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
      |                       ^~~~~~~~~
      |                       size_t
p808.cpp:938:38: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  938 | constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
      |                                      ^~~~~~~~~
      |                                      size_t
p808.cpp:938:52: error: expected primary-expression before 'const'
  938 | constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
      |                                                    ^~~~~
p808.cpp:938:68: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  938 | constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
      |                                                                    ^~~~~~~~~
      |                                                                    size_t
p808.cpp:941:46: error: 'charT' was not declared in this scope; did you mean 'char'?
  941 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
      |                                              ^~~~~
      |                                              char
p808.cpp:941:53: error: 'traits' was not declared in this scope
  941 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
      |                                                     ^~~~~~
p808.cpp:941:59: error: template argument 1 is invalid
  941 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
      |                                                           ^
p808.cpp:941:59: error: template argument 2 is invalid
p808.cpp:941:70: error: non-member function 'constexpr bool starts_with(int)' cannot have cv-qualifier
  941 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
      |                                                                      ^~~~~~~~
p808.cpp:942:28: error: 'constexpr const bool starts_with' redeclared as different kind of entity
  942 | constexpr bool starts_with(charT x) const noexcept;
      |                            ^~~~~
p808.cpp:941:16: note: previous declaration 'constexpr bool starts_with(int)'
  941 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
      |                ^~~~~~~~~~~
p808.cpp:942:28: error: 'charT' was not declared in this scope; did you mean 'char'?
  942 | constexpr bool starts_with(charT x) const noexcept;
      |                            ^~~~~
      |                            char
p808.cpp:943:34: error: 'charT' does not name a type; did you mean 'char'?
  943 | constexpr bool starts_with(const charT* x) const;
      |                                  ^~~~~
      |                                  char
p808.cpp:943:44: error: non-member function 'constexpr bool starts_with(const int*)' cannot have cv-qualifier
  943 | constexpr bool starts_with(const charT* x) const;
      |                                            ^~~~~
p808.cpp:945:1: error: expected unqualified-id before 'return'
  945 | return basic_string_view<charT, traits>(data(), size()).starts_with(x);
      | ^~~~~~
p808.cpp:947:44: error: 'charT' was not declared in this scope; did you mean 'char'?
  947 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
      |                                            ^~~~~
      |                                            char
p808.cpp:947:51: error: 'traits' was not declared in this scope
  947 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
      |                                                   ^~~~~~
p808.cpp:947:57: error: template argument 1 is invalid
  947 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
      |                                                         ^
p808.cpp:947:57: error: template argument 2 is invalid
p808.cpp:947:68: error: non-member function 'constexpr bool ends_with(int)' cannot have cv-qualifier
  947 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
      |                                                                    ^~~~~~~~
p808.cpp:948:26: error: 'constexpr const bool ends_with' redeclared as different kind of entity
  948 | constexpr bool ends_with(charT x) const noexcept;
      |                          ^~~~~
p808.cpp:947:16: note: previous declaration 'constexpr bool ends_with(int)'
  947 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
      |                ^~~~~~~~~
p808.cpp:948:26: error: 'charT' was not declared in this scope; did you mean 'char'?
  948 | constexpr bool ends_with(charT x) const noexcept;
      |                          ^~~~~
      |                          char
p808.cpp:949:32: error: 'charT' does not name a type; did you mean 'char'?
  949 | constexpr bool ends_with(const charT* x) const;
      |                                ^~~~~
      |                                char
p808.cpp:949:42: error: non-member function 'constexpr bool ends_with(const int*)' cannot have cv-qualifier
  949 | constexpr bool ends_with(const charT* x) const;
      |                                          ^~~~~
p808.cpp:951:1: error: expected unqualified-id before 'return'
  951 | return basic_string_view<charT, traits>(data(), size()).ends_with(x);
      | ^~~~~~
p808.cpp:953:43: error: 'charT' was not declared in this scope; did you mean 'char'?
  953 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
      |                                           ^~~~~
      |                                           char
p808.cpp:953:50: error: 'traits' was not declared in this scope
  953 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
      |                                                  ^~~~~~
p808.cpp:953:56: error: template argument 1 is invalid
  953 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
      |                                                        ^
p808.cpp:953:56: error: template argument 2 is invalid
p808.cpp:953:67: error: non-member function 'constexpr bool contains(int)' cannot have cv-qualifier
  953 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
      |                                                                   ^~~~~~~~
p808.cpp:954:25: error: 'constexpr const bool contains' redeclared as different kind of entity
  954 | constexpr bool contains(charT x) const noexcept;
      |                         ^~~~~
p808.cpp:953:16: note: previous declaration 'constexpr bool contains(int)'
  953 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
      |                ^~~~~~~~
p808.cpp:954:25: error: 'charT' was not declared in this scope; did you mean 'char'?
  954 | constexpr bool contains(charT x) const noexcept;
      |                         ^~~~~
      |                         char
p808.cpp:955:31: error: 'charT' does not name a type; did you mean 'char'?
  955 | constexpr bool contains(const charT* x) const;
      |                               ^~~~~
      |                               char
p808.cpp:955:41: error: non-member function 'constexpr bool contains(const int*)' cannot have cv-qualifier
  955 | constexpr bool contains(const charT* x) const;
      |                                         ^~~~~
p808.cpp:957:1: error: expected unqualified-id before 'return'
  957 | return basic_string_view<charT, traits>(data(), size()).contains(x);
      | ^~~~~~
p808.cpp:961:13: error: reference to 'basic_string' is ambiguous
  961 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:965:13: error: reference to 'basic_string' is ambiguous
  965 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:970:8: error: expected unqualified-id before 'return'
  970 |        return std::move(lhs);
      |        ^~~~~~
p808.cpp:971:17: error: 'charT' does not name a type; did you mean 'char'?
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                 ^~~~~
      |                 char
p808.cpp:971:42: error: 'charT' was not declared in this scope; did you mean 'char'?
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                          ^~~~~
      |                                          char
p808.cpp:971:49: error: 'traits' was not declared in this scope
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                                 ^~~~~~
p808.cpp:971:57: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                                         ^~~~~~~~~
      |                                                         alloca
p808.cpp:971:42: error: 'charT' was not declared in this scope; did you mean 'char'?
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                          ^~~~~
      |                                          char
p808.cpp:971:49: error: 'traits' was not declared in this scope
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                                 ^~~~~~
p808.cpp:971:57: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                                         ^~~~~~~~~
      |                                                         alloca
p808.cpp:971:42: error: 'charT' was not declared in this scope; did you mean 'char'?
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                          ^~~~~
      |                                          char
p808.cpp:971:49: error: 'traits' was not declared in this scope
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                                 ^~~~~~
p808.cpp:971:57: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                                         ^~~~~~~~~
      |                                                         alloca
p808.cpp:971:42: error: 'charT' was not declared in this scope; did you mean 'char'?
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                          ^~~~~
      |                                          char
p808.cpp:971:49: error: 'traits' was not declared in this scope
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                                 ^~~~~~
p808.cpp:971:57: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                                         ^~~~~~~~~
      |                                                         alloca
p808.cpp:971:29: error: reference to 'basic_string' is ambiguous
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:971:29: error: 'basic_string' has not been declared
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                             ^~~~~~~~~~~~
p808.cpp:971:41: error: expected ',' or '...' before '<' token
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                         ^
p808.cpp:971:74: error: expected constructor, destructor, or type conversion before ';' token
  971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
      |                                                                          ^
p808.cpp:973:4: error: expected unqualified-id before 'return'
  973 |    return std::move(rhs);
      |    ^~~~~~
p808.cpp:975:13: error: reference to 'basic_string' is ambiguous
  975 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:979:4: error: expected unqualified-id before 'return'
  979 |    return std::move(lhs);
      |    ^~~~~~
p808.cpp:983:13: error: reference to 'basic_string' is ambiguous
  983 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:987:13: error: reference to 'basic_string' is ambiguous
  987 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:992:24: error: 'traits' was not declared in this scope
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:992:24: error: 'traits' was not declared in this scope
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:992:24: error: 'traits' was not declared in this scope
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:992:24: error: 'traits' was not declared in this scope
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:992:24: error: 'traits' was not declared in this scope
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:992:24: error: 'traits' was not declared in this scope
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:992:24: error: 'traits' was not declared in this scope
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:992:24: error: 'traits' was not declared in this scope
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:992:24: error: 'traits' was not declared in this scope
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:992:4: error: reference to 'basic_string' is ambiguous
  992 |    basic_string<charT, traits, Allocator> r = rhs;
      |    ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:993:4: error: 'r' does not name a type
  993 |    r.insert(0, lhs);
      |    ^
p808.cpp:994:4: error: expected unqualified-id before 'return'
  994 |    return r;
      |    ^~~~~~
p808.cpp:996:13: error: reference to 'basic_string' is ambiguous
  996 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:999:24: error: 'traits' was not declared in this scope
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:999:24: error: 'traits' was not declared in this scope
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:999:24: error: 'traits' was not declared in this scope
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:999:24: error: 'traits' was not declared in this scope
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:999:24: error: 'traits' was not declared in this scope
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:999:24: error: 'traits' was not declared in this scope
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:999:24: error: 'traits' was not declared in this scope
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:999:24: error: 'traits' was not declared in this scope
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                 ^~~~~
      |                 char
p808.cpp:999:24: error: 'traits' was not declared in this scope
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                        ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:999:4: error: reference to 'basic_string' is ambiguous
  999 |    basic_string<charT, traits, Allocator> r = rhs;
      |    ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:1000:4: error: 'r' does not name a type
 1000 |    r.insert(r.begin(), lhs);
      |    ^
p808.cpp:1001:4: error: expected unqualified-id before 'return'
 1001 |    return r;
      |    ^~~~~~
p808.cpp:1003:13: error: reference to 'basic_string' is ambiguous
 1003 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:1006:4: error: expected unqualified-id before 'return'
 1006 |    return std::move(rhs);
      |    ^~~~~~
p808.cpp:1008:13: error: reference to 'basic_string' is ambiguous
 1008 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                 ^~~~~
      |                 char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                        ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                 ^~~~~
      |                 char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                        ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                 ^~~~~
      |                 char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                        ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                 ^~~~~
      |                 char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                        ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                 ^~~~~
      |                 char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                        ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                 ^~~~~
      |                 char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                        ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                 ^~~~~
      |                 char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                        ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                 ^~~~~
      |                 char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                        ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                 ^~~~~
      |                 char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                        ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |                                ^~~~~~~~~
      |                                alloca
p808.cpp:1011:4: error: reference to 'basic_string' is ambiguous
 1011 |    basic_string<charT, traits, Allocator> r = lhs;
      |    ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:1012:4: error: 'r' does not name a type
 1012 |    r.push_back(rhs);
      |    ^
p808.cpp:1013:4: error: expected unqualified-id before 'return'
 1013 |    return r;
      |    ^~~~~~
p808.cpp:1014:11: error: 'see' does not name a type
 1014 | constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
      |           ^~~
p808.cpp:1016:1: error: expected unqualified-id before 'return'
 1016 | return basic_string_view<charT, traits>(lhs) op basic_string_view<charT, traits>(rhs);
      | ^~~~~~
p808.cpp:1018:13: error: reference to 'basic_string' is ambiguous
 1018 |   constexpr basic_string<charT, traits, Allocator>
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:1021:8: error: expected unqualified-id before 'return'
 1021 |        return std::move(lhs);
      |        ^~~~~~
p808.cpp:1025:22: error: reference to 'basic_string' is ambiguous
 1025 |     operator==(const basic_string<charT, traits, Allocator>& lhs,
      |                      ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:1025:34: error: expected ',' or '...' before '<' token
 1025 |     operator==(const basic_string<charT, traits, Allocator>& lhs,
      |                                  ^
p808.cpp:1025:5: error: 'constexpr bool operator==(int)' must have an argument of class or enumerated type
 1025 |     operator==(const basic_string<charT, traits, Allocator>& lhs,
      |     ^~~~~~~~
p808.cpp:1028:35: error: reference to 'basic_string' is ambiguous
 1028 |   constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
      |                                   ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:1028:47: error: expected ',' or '...' before '<' token
 1028 |   constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
      |                                               ^
p808.cpp:1028:18: error: 'constexpr bool operator==(int)' must have an argument of class or enumerated type
 1028 |   constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
      |                  ^~~~~~~~
p808.cpp:1031:11: error: 'see_below' does not name a type
 1031 | constexpr see_below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
      |           ^~~~~~~~~
p808.cpp:1035:10: error: declaration of template parameter 'charT' shadows template parameter
 1035 | template<class charT, class traits, class Allocator>
      |          ^~~~~
p808.cpp:1033:10: note: template parameter 'charT' declared here
 1033 | template<class charT, class traits, class Allocator>
      |          ^~~~~
p808.cpp:1035:23: error: declaration of template parameter 'traits' shadows template parameter
 1035 | template<class charT, class traits, class Allocator>
      |                       ^~~~~
p808.cpp:1033:23: note: template parameter 'traits' declared here
 1033 | template<class charT, class traits, class Allocator>
      |                       ^~~~~
p808.cpp:1035:37: error: declaration of template parameter 'Allocator' shadows template parameter
 1035 | template<class charT, class traits, class Allocator>
      |                                     ^~~~~
p808.cpp:1033:37: note: template parameter 'Allocator' declared here
 1033 | template<class charT, class traits, class Allocator>
      |                                     ^~~~~
p808.cpp:1037:5: error: too many template-parameter-lists
 1037 |     swap(basic_string<charT, traits, Allocator>& lhs,
      |     ^~~~
p808.cpp:1044:46: error: reference to 'basic_string' is ambiguous
 1044 | operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
      |                                              ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:1044:46: error: 'basic_string' has not been declared
 1044 | operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
      |                                              ^~~~~~~~~~~~
p808.cpp:1044:58: error: expected ',' or '...' before '<' token
 1044 | operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
      |                                                          ^
p808.cpp:1054:22: error: reference to 'basic_string' is ambiguous
 1054 |                const basic_string<charT, traits, Allocator>& str);
      |                      ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:1054:34: error: expected ',' or '...' before '<' token
 1054 |                const basic_string<charT, traits, Allocator>& str);
      |                                  ^
p808.cpp:1059:13: error: reference to 'basic_string' is ambiguous
 1059 |             basic_string<charT, traits, Allocator>& str,
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:1059:13: error: 'basic_string' has not been declared
 1059 |             basic_string<charT, traits, Allocator>& str,
      |             ^~~~~~~~~~~~
p808.cpp:1059:25: error: expected ',' or '...' before '<' token
 1059 |             basic_string<charT, traits, Allocator>& str,
      |                         ^
p808.cpp:1064:13: error: reference to 'basic_string' is ambiguous
 1064 |             basic_string<charT, traits, Allocator>& str,
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:1064:13: error: 'basic_string' has not been declared
 1064 |             basic_string<charT, traits, Allocator>& str,
      |             ^~~~~~~~~~~~
p808.cpp:1064:25: error: expected ',' or '...' before '<' token
 1064 |             basic_string<charT, traits, Allocator>& str,
      |                         ^
p808.cpp:1075:13: error: reference to 'basic_string' is ambiguous
 1075 |             basic_string<charT, traits, Allocator>& str);
      |             ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:1075:13: error: 'basic_string' has not been declared
 1075 |             basic_string<charT, traits, Allocator>& str);
      |             ^~~~~~~~~~~~
p808.cpp:1075:25: error: expected ',' or '...' before '<' token
 1075 |             basic_string<charT, traits, Allocator>& str);
      |                         ^
p808.cpp:1079:9: error: reference to 'basic_string' is ambiguous
 1079 |         basic_string<charT, traits, Allocator>& str);
      |         ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
   22 |       class basic_string;
      |             ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note:                 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
   72 |     class basic_string;
      |           ^~~~~~~~~~~~
p808.cpp:494:11: note:                 'constexpr int basic_string(const int&, const int&)'
  494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
      |           ^~~~~~~~~~~~
p808.cpp:487:13: note:                 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
  487 |   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:478:11: note:                 'constexpr int basic_string(const int*, const int&)'
  478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:474:11: note:                 'constexpr int basic_string(const int*, int, const int&)'
  474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
      |           ^~~~~~~~~~~~
p808.cpp:470:22: note:                 'template<class T> constexpr int basic_string(const T&, const int&)'
  470 |   constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
      |                      ^~~~~~~~~~~~
p808.cpp:466:13: note:                 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
  466 |   constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
      |             ^~~~~~~~~~~~
p808.cpp:462:11: note:                 'constexpr int basic_string(const int&, int, int, const int&)'
  462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
      |           ^~~~~~~~~~~~
p808.cpp:460:11: note:                 'constexpr int basic_string(const int&, int, const int&)'
  460 | constexpr basic_string(const basic_string& str, size_type pos,
      |           ^~~~~~~~~~~~
p808.cpp:456:20: note:                 'constexpr int basic_string(const int&)'
  456 | constexpr explicit basic_string(const Allocator& a) noexcept;
      |                    ^~~~~~~~~~~~
p808.cpp:1079:9: error: 'basic_string' has not been declared
 1079 |         basic_string<charT, traits, Allocator>& str);
      |         ^~~~~~~~~~~~
p808.cpp:1079:21: error: expected ',' or '...' before '<' token
 1079 |         basic_string<charT, traits, Allocator>& str);
      |                     ^
p808.cpp:1083:22: error: expected nested-name-specifier before 'basic_string'
 1083 |   constexpr typename basic_string<charT, traits, Allocator>::size_type
      |                      ^~~~~~~~~~~~
p808.cpp:1083:34: error: expected initializer before '<' token
 1083 |   constexpr typename basic_string<charT, traits, Allocator>::size_type
      |                                  ^
p808.cpp:1086:21: error: 'c' was not declared in this scope
 1086 |    auto it = remove(c.begin(), c.end(), value);
      |                     ^
p808.cpp:1086:32: error: 'c' was not declared in this scope
 1086 |    auto it = remove(c.begin(), c.end(), value);
      |                                ^
p808.cpp:1086:41: error: 'value' was not declared in this scope
 1086 |    auto it = remove(c.begin(), c.end(), value);
      |                                         ^~~~~
p808.cpp:1087:26: error: 'c' was not declared in this scope
 1087 |    auto r = distance(it, c.end());
      |                          ^
p808.cpp:1088:4: error: 'c' does not name a type
 1088 |    c.erase(it, c.end());
      |    ^
p808.cpp:1089:4: error: expected unqualified-id before 'return'
 1089 |    return r;
      |    ^~~~~~
p808.cpp:1091:22: error: expected nested-name-specifier before 'basic_string'
 1091 |   constexpr typename basic_string<charT, traits, Allocator>::size_type
      |                      ^~~~~~~~~~~~
p808.cpp:1091:34: error: expected initializer before '<' token
 1091 |   constexpr typename basic_string<charT, traits, Allocator>::size_type
      |                                  ^
p808.cpp:1094:24: error: 'c' was not declared in this scope
 1094 |    auto it = remove_if(c.begin(), c.end(), pred);
      |                        ^
p808.cpp:1094:35: error: 'c' was not declared in this scope
 1094 |    auto it = remove_if(c.begin(), c.end(), pred);
      |                                   ^
p808.cpp:1094:44: error: 'pred' was not declared in this scope; did you mean 'pread'?
 1094 |    auto it = remove_if(c.begin(), c.end(), pred);
      |                                            ^~~~
      |                                            pread
p808.cpp:1094:14: error: 'remove_if' was not declared in this scope; did you mean 'remove'?
 1094 |    auto it = remove_if(c.begin(), c.end(), pred);
      |              ^~~~~~~~~
      |              remove
p808.cpp:1095:26: error: 'c' was not declared in this scope
 1095 |    auto r = distance(it, c.end());
      |                          ^
p808.cpp:1096:4: error: 'c' does not name a type
 1096 |    c.erase(it, c.end());
      |    ^
p808.cpp:1097:4: error: expected unqualified-id before 'return'
 1097 |    return r;
      |    ^~~~~~
p808.cpp:1150:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
 1150 | template<> struct hash<string>;
      |                   ^~~~~~~~~~~~
p808.cpp:1151:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
 1151 | template<> struct hash<u8string>;
      |                   ^~~~~~~~~~~~~~
p808.cpp:1152:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
 1152 | template<> struct hash<u16string>;
      |                   ^~~~~~~~~~~~~~~
p808.cpp:1153:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
 1153 | template<> struct hash<u32string>;
      |                   ^~~~~~~~~~~~~~~
p808.cpp:1154:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
 1154 | template<> struct hash<wstring>;
      |                   ^~~~~~~~~~~~~
p808.cpp:1155:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
 1155 | template<> struct hash<pmr::string>;
      |                   ^~~~~~~~~~~~~~~~~
p808.cpp:1156:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
 1156 | template<> struct hash<pmr::u8string>;
      |                   ^~~~~~~~~~~~~~~~~~~
p808.cpp:1157:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
 1157 | template<> struct hash<pmr::u16string>;
      |                   ^~~~~~~~~~~~~~~~~~~~
p808.cpp:1158:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
 1158 | template<> struct hash<pmr::u32string>;
      |                   ^~~~~~~~~~~~~~~~~~~~
p808.cpp:1159:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
 1159 | template<> struct hash<pmr::wstring>;
      |                   ^~~~~~~~~~~~~~~~~~
p808.cpp:1161:18: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
 1161 | constexpr string operator""s(const char* str, size_t len);
      |                  ^~~~~~~~
p808.cpp:1163:20: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
 1163 | constexpr u8string operator""s(const char8_t* str, size_t len);
      |                    ^~~~~~~~
p808.cpp:1165:21: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
 1165 | constexpr u16string operator""s(const char16_t* str, size_t len);
      |                     ^~~~~~~~
p808.cpp:1167:21: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
 1167 | constexpr u32string operator""s(const char32_t* str, size_t len);
      |                     ^~~~~~~~
p808.cpp:1169:19: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
 1169 | constexpr wstring operator""s(const wchar_t* str, size_t len);
      |                   ^~~~~~~~
p808.cpp:774:20: warning: 'erase' defined but not used [-Wunused-variable]
  774 | constexpr iterator erase(const_iterator p);
      |                    ^~~~~
p808.cpp:749:20: warning: 'insert' defined but not used [-Wunused-variable]
  749 | constexpr iterator insert(const_iterator p, charT c);
      |                    ^~~~~~

```

## 検討事項(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 初稿 　20220804