24.5 Unordered associative containers [unord] C++N4910:2022 (641) p925.cpp

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

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

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

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

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

https://stackoverflow.com

http://ja.cppreference.com/

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

https://cpprefjp.github.io/

コンパイラの実装状況

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

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

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

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

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

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

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

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

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

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

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

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

# 24.5 Unordered associative containers [unord] C++N4910:2022 (641) p925.cpp

## 算譜(source code)

```cpp:p925.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 = "24.5 Unordered associative containers [unord] C++N4910:2022 (641) p925.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;

// 24.5.1 In general [unord.general]
//  The header <unordered_map> defines the class templates unordered_map and unordered_multimap; the header <unordered_set> defines the class templates unordered_set and unordered_multiset.
//  The exposition-only alias templates iter-value-type , iter-key-type , iter-mapped-type , and iter-to-alloc-type defined in 24.4.1 may appear in deduction guides for unordered containers.
// 24.5.2 Header <unordered_map> synopsis [unord.map.syn]
#include <compare> // see 17.11.1 
#include <initializer_list> // see 17.10.2
namespace std {
// 24.5.4, class template unordered_map template<class Key,
class T,
          class Hash = hash<Key>,
                    class Pred = equal_to<Key>,
                              class Alloc = allocator<pair<const Key, T>>>
                                                class unordered_map;
// 24.5.5, class template unordered_multimap template<class Key,
class T,
          class Hash = hash<Key>,
                    class Pred = equal_to<Key>,
                              class Alloc = allocator<pair<const Key, T>>>
                                                class unordered_multimap;
template<class Key, class T, class Hash, class Pred, class Alloc>
bool operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
                const unordered_map<Key, T, Hash, Pred, Alloc>& b);
template<class Key, class T, class Hash, class Pred, class Alloc>
bool operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
                const unordered_multimap<Key, T, Hash, Pred, Alloc>& b);
template<class Key, class T, class Hash, class Pred, class Alloc>
void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
          unordered_map<Key, T, Hash, Pred, Alloc>& y)
noexcept(noexcept(x.swap(y)));
template<class Key, class T, class Hash, class Pred, class Alloc>
void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
          unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
noexcept(noexcept(x.swap(y)));
template<class K, class T, class H, class P, class A, class Predicate>
typename unordered_map<K, T, H, P, A>::size_type
erase_if(unordered_map<K, T, H, P, A>& c, Predicate pred);
template<class K, class T, class H, class P, class A, class Predicate>
typename unordered_multimap<K, T, H, P, A>::size_type
erase_if(unordered_multimap<K, T, H, P, A>& c, Predicate pred);
}
}
namespace pmr {
template<class Key,
         class T,
         class Hash = hash<Key>,
         class Pred = equal_to<Key>>
using unordered_map =
    std::unordered_map<Key, T, Hash, Pred,
    polymorphic_allocator<pair<const Key, T>>>;
template<class Key,
         class T,
         class Hash = hash<Key>,
         class Pred = equal_to<Key>>
using unordered_multimap =
    std::unordered_multimap<Key, T, Hash, Pred,
    polymorphic_allocator<pair<const Key, T>>>;
// 24.5.3 Header <unordered_set> synopsis  [unord.set.syn]
#include <compare> // see 17.11.1
#include <initializer_list> // see 17.10.2
namespace std {
// 24.5.6, class template unordered_set template<class Key,
class Hash = hash<Key>,
          class Pred = equal_to<Key>,
                    class Alloc = allocator<Key>>
                                      class unordered_set;
// 24.5.7, class template unordered_multiset template<class Key,
class Hash = hash<Key>,
          class Pred = equal_to<Key>,
                    class Alloc = allocator<Key>>
                                      class unordered_multiset;
template<class Key, class Hash, class Pred, class Alloc>
bool operator==(const unordered_set<Key, Hash, Pred, Alloc>& a,
                const unordered_set<Key, Hash, Pred, Alloc>& b);
template<class Key, class Hash, class Pred, class Alloc>
bool operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
                const unordered_multiset<Key, Hash, Pred, Alloc>& b);
template<class Key, class Hash, class Pred, class Alloc>
void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
          unordered_set<Key, Hash, Pred, Alloc>& y)
noexcept(noexcept(x.swap(y)));
template<class Key, class Hash, class Pred, class Alloc>
void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
          unordered_multiset<Key, Hash, Pred, Alloc>& y)
noexcept(noexcept(x.swap(y)));
template<class K, class H, class P, class A, class Predicate>
typename unordered_set<K, H, P, A>::size_type
erase_if(unordered_set<K, H, P, A>& c, Predicate pred);
template<class K, class H, class P, class A, class Predicate>
typename unordered_multiset<K, H, P, A>::size_type
erase_if(unordered_multiset<K, H, P, A>& c, Predicate pred);
namespace pmr {
template<class Key,
         class Hash = hash<Key>,
         class Pred = equal_to<Key>>
using unordered_set = std::unordered_set<Key, Hash, Pred,
      polymorphic_allocator<Key>>;
template<class Key,
         class Hash = hash<Key>,
         class Pred = equal_to<Key>>
using unordered_multiset = std::unordered_multiset<Key, Hash, Pred,
      polymorphic_allocator<Key>>;
// 24.5.4 Class template unordered_map [unord.map]
// 24.5.4.1 Overview [unord.map.overview]
//  An unordered_map is an unordered associative container that supports unique keys (an unordered_map contains at most one of each key value) and that associates values of another type mapped_type with the keys. The unordered_map class supports forward iterators.
//  An unordered_map meets all of the requirements of a container (24.2.2.2), of an allocator-aware container (24.2.2.5), and of an unordered associative container (24.2.8). It provides the operations described in the preceding requirements table for unique keys; that is, an unordered_map supports the a_uniq operations in that table, not the a_eq operations. For an unordered_map<Key, T> the key type is Key, the mapped type is T, and the value type is pair<const Key, T>.
//  Subclause 24.5.4 only describes operations on unordered_map that are not described in one of the requirement
tables, or for which there is additional semantic information.
namespace std {
template<class Key,
         class T,
         class Hash = hash<Key>,
         class Pred = equal_to<Key>,
         class Allocator = allocator<pair<const Key, T>>>
}
}
class unordered_map {
public:
// types
using key_type = Key;
using mapped_type = T;
using value_type = pair<const Key, T>;
using hasher = Hash;
using key_equal = Pred;
using allocator_type = Allocator;
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 size_type = implementation_defined ; // see 24.2
using difference_type = implementation_defined ; // see 24.2
using iterator = implementation_defined ; // see 24.2
using const_iterator = implementation_defined ; // see 24.2
using local_iterator = implementation_defined ; // see 24.2
using const_local_iterator = implementation_defined ; // see 24.2
using node_type = unspecified;
using insert_return_type = insert-return-type<iterator, node_type>; // // 24.5.4.2, construct/copy/destroy
unordered_map();
    explicit unordered_map(size_type n,
                           const hasher& hf = hasher(),
                           const key_equal& eql = key_equal(),
                           const allocator_type& a = allocator_type());
    template<class InputIterator>
    unordered_map(InputIterator f, InputIterator l, size_type n = see below,
                  const hasher& hf = hasher(),
                  const key_equal& eql = key_equal(),
                  const allocator_type& a = allocator_type());
    template<container-compatible-range<value_type> R> unordered_map(from_range_t, R&& rg, size_type n = see below,
            const hasher& hf = hasher(), const key_equal& eql = key_equal(),
            const allocator_type& a = allocator_type());
    unordered_map(const unordered_map&);
    unordered_map(unordered_map&&);
    explicit unordered_map(const Allocator&);
    unordered_map(const unordered_map&, const type_identity_t<Allocator>&);
    unordered_map(unordered_map&&, const type_identity_t<Allocator>&);
    unordered_map(initializer_list<value_type> il,
                  size_type n = see below,
                  const hasher& hf = hasher(),
                  const key_equal& eql = key_equal(),
                  const allocator_type& a = allocator_type());
    unordered_map(size_type n, const allocator_type& a)
        : unordered_map(n, hasher(), key_equal(), a) { }
    unordered_map(size_type n, const hasher& hf, const allocator_type& a)
        : unordered_map(n, hf, key_equal(), a) { }
    template<class InputIterator>
    unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
        : unordered_map(f, l, n, hasher(), key_equal(), a) { }
    template<class InputIterator>
    unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,
                  const allocator_type& a)
        : unordered_map(f, l, n, hf, key_equal(), a) { } template<container-compatible-range<value_type> R>
    unordered_map(from_range_t, R&& rg, size_type n, const allocator_type& a)
        : unordered_map(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { }
    template<container-compatible-range<value_type> R>
    unordered_map(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
        : unordered_map(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }
    unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
        : unordered_map(il, n, hasher(), key_equal(), a) { }
    unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf,
                  const allocator_type& a)
        : unordered_map(il, n, hf, key_equal(), a) { }
    ~unordered_map();
    unordered_map& operator=(const unordered_map&);
    unordered_map& operator=(unordered_map&&)
    noexcept(allocator_traits<Allocator>::is_always_equal::value &&
             is_nothrow_move_assignable_v<Hash> &&
             is_nothrow_move_assignable_v<Pred>);
    unordered_map& operator=(initializer_list<value_type>);
    allocator_type get_allocator() const noexcept;
// iterators
    iterator       begin() noexcept;
    const_iterator begin() const noexcept;
    iterator       end() noexcept;
    const_iterator end() const noexcept;
    const_iterator cbegin() const noexcept;
    const_iterator cend() const noexcept;
// capacity
    [[nodiscard]] bool empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;
// 24.5.4.4, modifiers
    template<class... Args> pair<iterator, bool> emplace(Args&&... args);
    template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args);
    pair<iterator, bool> insert(const value_type& obj);
    pair<iterator, bool> insert(value_type&& obj);
    template<class P> pair<iterator, bool> insert(P&& obj);
    iterator insert(const_iterator hint, const value_type& obj);
    iterator insert(const_iterator hint, value_type&& obj);
    template<class P> iterator insert(const_iterator hint, P&& obj);
    template<class InputIterator> void insert(InputIterator first, InputIterator last);
    template<container-compatible-range<value_type> R>
    void insert_range(R&& rg);
    void insert(initializer_list<value_type>);
    node_type extract(const_iterator position);
    node_type extract(const key_type& x);
    template<class K> node_type extract(K&& x);
    insert_return_type insert(node_type&& nh);
    iterator           insert(const_iterator hint, node_type&& nh);
    template<class... Args>
    pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
    template<class... Args>
    pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
    template<class... Args>
    iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
    template<class... Args>
    iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
    template<class M>
    pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
    template<class M>
    pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
    template<class M>
    iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
    template<class M>
    iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
    iterator  erase(iterator position);
    iterator  erase(const_iterator position);
    size_type erase(const key_type& k);
    template<class K> size_type erase(K&& x);
    iterator  erase(const_iterator first, const_iterator last);
    void      swap(unordered_map&)
    noexcept(allocator_traits<Allocator>::is_always_equal::value &&
             is_nothrow_swappable_v<Hash> &&
             is_nothrow_swappable_v<Pred>);
    void      clear() noexcept;
    template<class H2, class P2>
    void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
    template<class H2, class P2>
    void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
    template<class H2, class P2>
    void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);
    template<class H2, class P2>
    void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);
// observers
    hasher hash_function() const;
    key_equal key_eq() const;
// map operations
    iterator
    const_iterator
    template<class K>
    iterator
    template<class K>
    find(const key_type& k);
    find(const key_type& k) const;
    find(const K& k);
    const_iterator find(const K& k) const;
    template<class K>
    size_type        count(const key_type& k) const;
    template<class K>
    size_type      count(const K& k) const;
    bool             contains(const key_type& k) const;
    template<class K>
    bool           contains(const K& k) const;
    pair<iterator, iterator>
    pair<const_iterator, const_iterator>
    template<class K>
// 24.5.4.3, element access
    mapped_type& operator[](const key_type& k);
    mapped_type& operator[](key_type&& k);
    mapped_type& at(const key_type& k);
    const mapped_type& at(const key_type& k) const;
// bucket interface
    size_type bucket_count() const noexcept;
    size_type max_bucket_count() const noexcept;
    size_type bucket_size(size_type n) const;
    size_type bucket(const key_type& k) const;
    local_iterator begin(size_type n);
    const_local_iterator begin(size_type n) const;
    local_iterator end(size_type n);
    const_local_iterator end(size_type n) const;
    const_local_iterator cbegin(size_type n) const;
    const_local_iterator cend(size_type n) const;
// hash policy
    float load_factor() const noexcept;
    float max_load_factor() const noexcept;
    void max_load_factor(float z);
    void rehash(size_type n);
    void reserve(size_type n);
};
template<class InputIterator,
         class Hash = hash<iter_key_type<InputIterator>>,
         class Pred = equal_to<iter_key_type<InputIterator>>,
         class Allocator = allocator<iter_to_alloc_type<InputIterator>>>
                                     unordered_map(InputIterator, InputIterator, typename see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
                                     -> unordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash, Pred, Allocator>;
         template<ranges::input_range R, class Hash = hash<range_key_type<R>>, class Pred = equal_to<range-key-type<R>>,
                  class Allocator = allocator<range_to_alloc_type<R>>>
                          unordered_map(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
                          -> unordered_map<range_key_type<R>, range-mapped-type<R>, Hash, Pred, Allocator>;
                  equal_range(const key_type& k);
                  equal_range(const key_type& k) const;
                  equal_range(const K& k);
                  pair<const_iterator, const_iterator> equal_range(const K& k) const;
                  pair<iterator, iterator>
                  template<class K>
                  template<class Key, class T, class Hash = hash<Key>,
                           class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
                                   unordered_map(initializer_list<pair<Key, T>>,
                                           typename see below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
                                   -> unordered_map<Key, T, Hash, Pred, Allocator>;
                           template<class InputIterator, class Allocator>
                           unordered_map(InputIterator, InputIterator, typename see_below::size_type, Allocator)
                           -> unordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
                                   equal_to<iter-key-type<InputIterator>>, Allocator>;
                           template<class InputIterator, class Allocator>
                           unordered_map(InputIterator, InputIterator, Allocator)
                           -> unordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
                                   equal_to<iter_key_type<InputIterator>>, Allocator>;
                           template<class InputIterator, class Hash, class Allocator>
                           unordered_map(InputIterator, InputIterator, typename see_below::size_type, Hash, Allocator)
                           -> unordered_map<iter-key-type<InputIterator>, iter_mapped_type<InputIterator>, Hash, equal_to<iter_key_type<InputIterator>>, Allocator>;
template<ranges::\tcode{input_range} R, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Allocator)
    -> unordered_map<range_key_type<R>, range_mapped_type<R>, hash<range_key_type<R>>, equal_to<range_key_type<R>>, Allocator>;
template<ranges::input_range R, class Allocator>
unordered_map(from_range_t, R&&, Allocator)
-> unordered_map<range-key-type<R>, range_mapped_type<R>, hash<range-key-type<R>>, equal_to<range_key_type<R>>, Allocator>;
template<ranges::input_range R, class Hash, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
-> unordered_map<range-key-type<R>, range_mapped_type<R>, Hash, equal_to<range_key_type<R>>, Allocator>;
template<class Key, class T, class Allocator> unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type,
        Allocator)
-> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
template<class Key, class T, class Allocator>
unordered_map(initializer_list<pair<Key, T>>, Allocator)
-> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
template<class Key, class T, class Hash, class Allocator> unordered_map(initializer_list<pair<Key, T>>, typename see_below::size_type, Hash, Allocator)
-> unordered_map<Key, T, Hash, equal_to<Key>, Allocator>;
}
//  A size_type parameter type in an unordered_map deduction guide refers to the size_type member type of the type deduced by the deduction guide.
// 24.5.4.2 Constructors [unord.map.cnstr]
unordered_map() : unordered_map(size_type(see below)) { } explicit unordered_map(size_type n,
        const hasher& hf = hasher(),
        const key_equal& eql = key_equal(),
        const allocator_type& a = allocator_type());
// Effects: Constructs an empty unordered_map using the specified hash function, key equality predicate, and allocator, and using at least n buckets. For the default constructor, the number of buckets is implementation-defined. max_load_factor() returns 1.0.
// Complexity: Constant.
const hasher& hf = hasher(),
              const key_equal& eql = key_equal(),
                               const allocator_type& a = allocator_type());
// Effects: Constructs an empty unordered_map using the specified hash function, key equality predicate, and allocator, and using at least n buckets. If n is not provided, the number of buckets is implementation- defined. Then inserts elements from the range [f, l), rg, or il, respectively. max_load_factor() returns 1.0.
// Complexity: Average case linear, worst case quadratic.
template<class InputIterator>
unordered_map(InputIterator f, InputIterator l,
              size_type n = see_below,
              const hasher& hf = hasher(),
              const key_equal& eql = key_equal(),
              const allocator_type& a = allocator_type());
template<container-compatible-range<value_type> R> unordered_map(from_range_t, R&& rg,
        size_type n = see below,
        const hasher& hf = hasher(),
        const key_equal& eql = key_equal(),
        const allocator_type& a = allocator_type());
unordered_map(initializer_list<value_type> il, size_type n = see below,
// 24.5.4.3 Element access [unord.map.elem]
              mapped_type& operator[](const key_type& k);
// Effects: Equivalent to: return try_emplace(k).first->second; mapped_type& operator[](key_type&& k);
// Effects: Equivalent to: return try_emplace(move(k)).first->second; mapped_type& at(const key_type& k);
const mapped_type& at(const key_type& k) const;
// Returns: A reference to x.second, where x is the (unique) element whose key is equivalent to k. Throws: An exception object of type out_of_range if no such element is present.
// 24.5.4.4 Modifiers [unord.map.modifiers]
template<class P>
pair<iterator, bool> insert(P&& obj);
// Constraints: is_constructible_v<value_type, P&&> is true. Effects: Equivalent to: return emplace(std::forward<P>(obj));
template<class P>
iterator insert(const_iterator hint, P&& obj);
// Constraints: is_constructible_v<value_type, P&&> is true.
// Effects: Equivalent to: return emplace_hint(hint, std::forward<P>(obj));
template<class... Args>
pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
template<class... Args>
iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
// Preconditions: value_type is Cpp17EmplaceConstructible into unordered_map from piecewise_con- struct, forward_as_tuple(k), forward_as_tuple(std::forward<Args>(args)...).
// Effects: If the map already contains an element whose key is equivalent to k, there is no effect. Otherwise inserts an object of type value_type constructed with piecewise_construct, forward_as_tuple(k), forward_as_tuple(std::forward<Args>(args)...).
// Returns: In the first overload, the bool component of the returned pair is true if and only if the insertion took place. The returned iterator points to the map element whose key is equivalent to k.
// Complexity: The same as emplace and emplace_hint, respectively.
template<class... Args>
pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
template<class... Args>
iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
// Preconditions: value_type is Cpp17EmplaceConstructible into unordered_map from piecewise_con- struct, forward_as_tuple(std::move(k)), forward_as_tuple(std::forward<Args>(args)...).
// Effects: If the map already contains an element whose key is equivalent to k, there is no effect. Otherwise inserts an object of type value_type constructed with piecewise_construct, forward_- as_tuple(std::move(k)), forward_as_tuple(std::forward<Args>(args)...).
// Returns: In the first overload, the bool component of the returned pair is true if and only if the insertion took place. The returned iterator points to the map element whose key is equivalent to k.
// Complexity: The same as emplace and emplace_hint, respectively.
template<class M>
pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
template<class M>
iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
// Mandates: is_assignable_v<mapped_type&, M&&> is true.
// Preconditions: value_type is Cpp17EmplaceConstructible into unordered_map from k, std::for-
ward<M>(obj).
// Effects: If the map already contains an element e whose key is equivalent to k, assigns std::for- ward<M>(obj) to e.second. Otherwise inserts an object of type value_type constructed with k, std::forward<M>(obj).
// Returns: In the first overload, the bool component of the returned pair is true if and only if the insertion took place. The returned iterator points to the map element whose key is equivalent to k.
// Complexity: The same as emplace and emplace_hint, respectively.
template<class M>
pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
template<class M>
iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
// Mandates: is_assignable_v<mapped_type&, M&&> is true.
// Preconditions: value_type is Cpp17EmplaceConstructible into unordered_map from std::move(k),
std::forward<M>(obj).
// Effects: If the map already contains an element e whose key is equivalent to k, assigns std::for- ward<M>(obj) to e.second. Otherwise inserts an object of type value_type constructed with std:: move(k), std::forward<M>(obj).
// Returns: In the first overload, the bool component of the returned pair is true if and only if the insertion took place. The returned iterator points to the map element whose key is equivalent to k.
// Complexity: The same as emplace and emplace_hint, respectively.
// 24.5.4.5 Erasure [unord.map.erasure]
template<class K, class T, class H, class P, class A, class Predicate>
typename unordered_map<K, T, H, P, A>::size_type
erase_if(unordered_map<K, T, H, P, A>& c, Predicate pred);
// Effects: Equivalent to:
auto original_size = c.size();
for (auto i = c.begin(), last = c.end(); i != last; ) {
    if (pred(*i)) {
        i = c.erase(i);
    } else {
        ++i;
    }
}
return original_size - c.size();
// 24.5.5 Class template unordered_multimap  [unord.multimap]
// 24.5.5.1 Overview [unord.multimap.overview]
//  An unordered_multimap is an unordered associative container that supports equivalent keys (an instance of unordered_multimap may contain multiple copies of each key value) and that associates values of another type mapped_type with the keys. The unordered_multimap class supports forward iterators.
//  An unordered_multimap meets all of the requirements of a container (24.2.2.2), of an allocator-aware container (24.2.2.5), and of an unordered associative container (24.2.8). It provides the operations described in the preceding requirements table for equivalent keys; that is, an unordered_multimap supports the a_eq operations in that table, not the a_uniq operations. For an unordered_multimap<Key, T> the key type is Key, the mapped type is T, and the value type is pair<const Key, T>.
//  Subclause 24.5.5 only describes operations on unordered_multimap that are not described in one of the requirement tables, or for which there is additional semantic information.
namespace std {
template<class Key,
         class T,
         class Hash = hash<Key>,
         class Pred = equal_to<Key>,
         class Allocator = allocator<pair<const Key, T>>>
class unordered_multimap {
public:
// types
    using key_type = Key;
    using mapped_type =T;
    using value_type = pair<const Key, T>;
    using hasher = Hash;
    using key_equal = Pred;
    using allocator_type = Allocator;
    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 size_type = implementation_defined ; // see 24.2
    using difference_type = implementation_defined ; // see 24.2
    using iterator = implementation_defined ; // see 24.2
    using const_iterator = implementation_defined ; // see 24.2
    using local_iterator = implementation_defined ; // see 24.2
    using const_local_iterator = implementation_defined ; // see 24.2
    using node_type  = unspecified;
// 24.5.5.2, construct/copy/destroy unordered_multimap();
    explicit unordered_multimap(size_type n,
                                const hasher& hf = hasher(),
                                const key_equal& eql = key_equal(),
                                const allocator_type& a = allocator_type());
    template<class InputIterator>
    unordered_multimap(InputIterator f, InputIterator l, size_type n = see_below,
                       const hasher& hf = hasher(),
                       const key_equal& eql = key_equal(),
                       const allocator_type& a = allocator_type());
    template<container-compatible-range<value_type> R> unordered_multimap(from_range_t, R&& rg,
            size_type n = see_below,
            const hasher& hf = hasher(),
            const key_equal& eql = key_equal(),
            const allocator_type& a = allocator_type());
    unordered_multimap(const unordered_multimap&);
    unordered_multimap(unordered_multimap&&);
    explicit unordered_multimap(const Allocator&);
    unordered_multimap(const unordered_multimap&, const type_identity_t<Allocator>&);
    unordered_multimap(unordered_multimap&&, const type_identity_t<Allocator>&);
    unordered_multimap(initializer_list<value_type> il,
                       size_type n = see_below,
                       const hasher& hf = hasher(),
                       const key_equal& eql = key_equal(),
                       const allocator_type& a = allocator_type());
    unordered_multimap(size_type n, const allocator_type& a)
        : unordered_multimap(n, hasher(), key_equal(), a) { }
    unordered_multimap(size_type n, const hasher& hf, const allocator_type& a)
        : unordered_multimap(n, hf, key_equal(), a) { }
    template<class InputIterator>
    unordered_multimap(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
        : unordered_multimap(f, l, n, hasher(), key_equal(), a) { }
    template<class InputIterator>
    unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf,
                       const allocator_type& a)
        : unordered_multimap(f, l, n, hf, key_equal(), a) { } template<container_compatible_range<value_type> R>
    unordered_multimap(from_range_t, R&& rg, size_type n, const allocator_type& a)
        : unordered_multimap(from_range, std::forward<R>(rg),
                             n, hasher(), key_equal(), a) { } template<container_compatible_range<value_type> R>
    unordered_multimap(from_range_t, R&& rg, size_type n, const hasher& hf,
                       const allocator_type& a)
        : unordered_multimap(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }
    unordered_multimap(initializer_list<value_type> il, size_type n, const allocator_type& a)
        : unordered_multimap(il, n, hasher(), key_equal(), a) { }
    unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf,
                       const allocator_type& a)
        : unordered_multimap(il, n, hf, key_equal(), a) { }
    ~unordered_multimap();
    unordered_multimap& operator=(const unordered_multimap&); unordered_multimap& operator=(unordered_multimap&&)
    noexcept(allocator_traits<Allocator>::is_always_equal::value &&
             is_nothrow_move_assignable_v<Hash> &&
             is_nothrow_move_assignable_v<Pred>);
    unordered_multimap& operator=(initializer_list<value_type>);
    allocator_type get_allocator() const noexcept;
// iterators
    iterator       begin() noexcept;
    const_iterator begin() const noexcept;
    iterator       end() noexcept;
    const_iterator end() const noexcept;
    const_iterator cbegin() const noexcept;
    const_iterator cend() const noexcept;
// capacity
    [[nodiscard]] bool empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;
// 24.5.5.3, modifiers
    template<class... Args> iterator emplace(Args&&... args);
    template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj);
    iterator insert(value_type&& obj);
    template<class P> iterator insert(P&& obj);
    iterator insert(const_iterator hint, const value_type& obj);
    iterator insert(const_iterator hint, value_type&& obj);
    template<class P> iterator insert(const_iterator hint, P&& obj);
    template<class InputIterator> void insert(InputIterator first, InputIterator last); template<container-compatible-range<value_type> R>
    void insert_range(R&& rg);
    void insert(initializer_list<value_type>);
    node_type extract(const_iterator position);
    node_type extract(const key_type& x);
    template<class K> node_type extract(K&& x);
    iterator insert(node_type&& nh);
    iterator insert(const_iterator hint, node_type&& nh);
    iterator  erase(iterator position);
    iterator  erase(const_iterator position);
    size_type erase(const key_type& k);
    template<class K> size_type erase(K&& x);
    iterator  erase(const_iterator first, const_iterator last);
    void      swap(unordered_multimap&)
    noexcept(allocator_traits<Allocator>::is_always_equal::value &&
             is_nothrow_swappable_v<Hash> &&
             is_nothrow_swappable_v<Pred>);
    void      clear() noexcept;
    template<class H2, class P2>
    void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);
    template<class H2, class P2>
    void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);
    template<class H2, class P2>
    void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
    template<class H2, class P2>
    void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
// observers
    hasher hash_function() const;
    key_equal key_eq() const;
// map operations
    iterator
    const_iterator
    template<class K>
    iterator
    template<class K>
    find(const key_type& k);
    find(const key_type& k) const;
    find(const K& k);
    const_iterator find(const K& k) const;
    size_type
    template<class K>
    size_type
    bool
    count(const key_type& k) const;
    count(const K& k) const;
    contains(const key_type& k) const;
    template<class K>
    bool           contains(const K& k) const;
    pair<iterator, iterator>
    pair<const_iterator, const_iterator>
    template<class K>
// bucket interface
    size_type bucket_count() const noexcept;
    size_type max_bucket_count() const noexcept;
    size_type bucket_size(size_type n) const;
    size_type bucket(const key_type& k) const;
    local_iterator begin(size_type n);
    const_local_iterator begin(size_type n) const;
    local_iterator end(size_type n);
    const_local_iterator end(size_type n) const;
    const_local_iterator cbegin(size_type n) const;
    const_local_iterator cend(size_type n) const;
// hash policy
    float load_factor() const noexcept;
    float max_load_factor() const noexcept;
    void max_load_factor(float z);
    void rehash(size_type n);
    void reserve(size_type n);
    equal_range(const key_type& k);
    equal_range(const key_type& k) const;
    equal_range(const K& k);
    pair<const_iterator, const_iterator> equal_range(const K& k) const;
    pair<iterator, iterator>
    template<class K>
};
template<class InputIterator,
         class Hash = hash<iter_key_type<InputIterator>>,
         class Pred = equal_to<iter-key-type<InputIterator>>,
         class Allocator = allocator<iter_to_alloc_type<InputIterator>>>
                                     unordered_multimap(InputIterator, InputIterator,
                                             typename see_below::size_type = see_below,
                                             Hash = Hash(), Pred = Pred(), Allocator = Allocator())
                                     -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>,
                                             Hash, Pred, Allocator>;
         template<ranges::input_range R,
                  class Hash = hash<range_key_type<R>>,
                  class Pred = equal_to<range_key_type<R>>,
                  class Allocator = allocator<range_to_alloc_type<R>>>
                          unordered_multimap(from_range_t, R&&, typename see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
                          -> unordered_multimap<range_key_type<R>, range_mapped_type<R>, Hash, Pred, Allocator>;
                  template<class Key, class T, class Hash = hash<Key>,
                           class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
                                   unordered_multimap(initializer_list<pair<Key, T>>,
                                           typename see below::size_type = see below,
                                           Hash = Hash(), Pred = Pred(), Allocator = Allocator())
                                   -> unordered_multimap<Key, T, Hash, Pred, Allocator>;
                           template<class InputIterator, class Allocator>
                           unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Allocator)
                           -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
                                   equal_to<iter-key-type<InputIterator>>, Allocator>;
                           template<class InputIterator, class Allocator>
                           unordered_multimap(InputIterator, InputIterator, Allocator)
                           -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
// Effects: Constructs an empty unordered_multimap using the specified hash function, key equality predicate, and allocator, and using at least n buckets. For the default constructor, the number of buckets is implementation-defined. max_load_factor() returns 1.0. Complexity: Constant.
                                   equal_to<iter_key_type<InputIterator>>, Allocator>;
                           template<class InputIterator, class Hash, class Allocator> unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Hash,
                                   Allocator)
                           -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash,
                                   equal_to<iter_key_type<InputIterator>>, Allocator>;
                           template<ranges::input_range R, class Allocator>
                           unordered_multimap(from_range_t, R&&, typename see_below::size_type, Allocator)
                           -> unordered_multimap<range_key_type<R>, range_mapped_type<R>, hash<range_key_type<R>>, equal_to<range_key_type<R>>, Allocator>;
                           template<ranges::input_range R, class Allocator>
                           unordered_multimap(from_range_t, R&&, Allocator)
                           -> unordered_multimap<range_key_type<R>, range_mapped_type<R>, hash<range_key_type<R>>, equal_to<range_key_type<R>>, Allocator>;
                           template<ranges::input_range R, class Hash, class Allocator> unordered_multimap(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
                           -> unordered_multimap<range-key-type<R>, range_mapped_type<R>, Hash, equal_to<range_key_type<R>>, Allocator>;
                           template<class Key, class T, class Allocator> unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type,
                                   Allocator)
                           -> unordered_multimap<Key, T, hash<Key>, equal_to<Key>, Allocator>;
                           template<class Key, class T, class Allocator>
                           unordered_multimap(initializer_list<pair<Key, T>>, Allocator)
                           -> unordered_multimap<Key, T, hash<Key>, equal_to<Key>, Allocator>;
                           template<class Key, class T, class Hash, class Allocator> unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type,
                                   Hash, Allocator)
                           -> unordered_multimap<Key, T, Hash, equal_to<Key>, Allocator>;
}
//  A size_type parameter type in an unordered_multimap deduction guide refers to the size_type member type of the type deduced by the deduction guide.
// 24.5.5.2 Constructors [unord.multimap.cnstr]
                           unordered_multimap() : unordered_multimap(size_type(see below)) { } explicit unordered_multimap(size_type n,
                                   const hasher& hf = hasher(),
                                   const key_equal& eql = key_equal(),
                                   const allocator_type& a = allocator_type());
template<class InputIterator>
unordered_multimap(InputIterator f, InputIterator l,
                   size_type n = see_below,
                   const hasher& hf = hasher(),
                   const key_equal& eql = key_equal(),
                   const allocator_type& a = allocator_type());
template<container_compatible_range<value_type> R> unordered_multimap(from_range_t, R&& rg,
        size_type n = see_below,
        const hasher& hf = hasher(),
        const key_equal& eql = key_equal(),
        const allocator_type& a = allocator_type());
unordered_multimap(initializer_list<value_type> il,
                   size_type n = see_below,
                   const hasher& hf = hasher(),
                   const key_equal& eql = key_equal(),
                   const allocator_type& a = allocator_type());
// Effects: Constructs an empty unordered_multimap using the specified hash function, key equality predicate, and allocator, and using at least n buckets. If n is not provided, the number of buckets is implementation-defined. Then inserts elements from the range [f,l), rg, or il, respectively. max_- load_factor() returns 1.0.
// Complexity: Average case linear, worst case quadratic.
// 24.5.5.3 Modifiers [unord.multimap.modifiers]
template<class P>
iterator insert(P&& obj);
// Constraints: is_constructible_v<value_type, P&&> is true. Effects: Equivalent to: return emplace(std::forward<P>(obj));
template<class P>
iterator insert(const_iterator hint, P&& obj);
// Constraints: is_constructible_v<value_type, P&&> is true.
Effects: Equivalent to: return emplace_hint(hint, std::forward<P>(obj));
// 24.5.5.4 Erasure [unord.multimap.erasure]
template<class K, class T, class H, class P, class A, class Predicate>
typename unordered_multimap<K, T, H, P, A>::size_type
erase_if(unordered_multimap<K, T, H, P, A>& c, Predicate pred);
// Effects: Equivalent to:
auto original_size = c.size();
for (auto i = c.begin(), last = c.end(); i != last; ) {
    if (pred(*i)) {
        i = c.erase(i);
    } else {
        ++i;
    }
}
return original_size - c.size();
// 24.5.6 Class template unordered_set  [unord.set]
// 24.5.6.1 Overview [unord.set.overview]
//  An unordered_set is an unordered associative container that supports unique keys (an unordered_set contains at most one of each key value) and in which the elements’ keys are the elements themselves. The unordered_set class supports forward iterators.
//  An unordered_set meets all of the requirements of a container (24.2.2.2), of an allocator-aware container (24.2.2.5), of an unordered associative container (24.2.8). It provides the operations described in the preceding requirements table for unique keys; that is, an unordered_set supports the a_uniq operations in that table, not the a_eq operations. For an unordered_set<Key> the key type and the value type are both Key. The iterator and const_iterator types are both constant iterator types. It is unspecified whether they are the same type.
//  Subclause 24.5.6 only describes operations on unordered_set that are not described in one of the requirement tables, or for which there is additional semantic information.
namespace std {
template<class Key,
         class Hash = hash<Key>,
         class Pred = equal_to<Key>,
         class Allocator = allocator<Key>>
class unordered_set {
public:
// types
    using key_type = Key;
    using value_type = Key;
    using hasher = Hash;
    using key_equal = Pred;
    using allocator_type = Allocator;
    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 size_type = implementation_defined ; // see 24.2
    using difference_type = implementation_defined ; // see 24.2
    using iterator = implementation_defined ; // see 24.2
    using const_iterator = implementation_defined ; // see 24.2
    using local_iterator = implementation_defined ; // see 24.2
    using const_local_iterator = implementation_defined ; // see 24.2
    using node_type  = unspecified;
    using insert_return_type = insert-return-type<iterator, node_type>;
// 24.5.6.2, construct/copy/destroy unordered_set();
    explicit unordered_set(size_type n,
                           const hasher& hf = hasher(),
                           const key_equal& eql = key_equal(),
                           const allocator_type& a = allocator_type());
    template<class InputIterator>
    unordered_set(InputIterator f, InputIterator l,
                  size_type n = see_below,
                  const hasher& hf = hasher(),
                  const key_equal& eql = key_equal(),
                  const allocator_type& a = allocator_type());
    template<container_compatible_range<value_type> R> unordered_set(from_range_t, R&& rg,
            size_type n = see_below,
            const hasher& hf = hasher(),
            const key_equal& eql = key_equal(),
            const allocator_type& a = allocator_type());
    unordered_set(const unordered_set&);
    unordered_set(unordered_set&&);
    explicit unordered_set(const Allocator&);
    unordered_set(const unordered_set&, const type_identity_t<Allocator>&);
    unordered_set(unordered_set&&, const type_identity_t<Allocator>&);
    unordered_set(initializer_list<value_type> il,
                  size_type n = see below,
                  const hasher& hf = hasher(),
                  const key_equal& eql = key_equal(),
                  const allocator_type& a = allocator_type());
    unordered_set(size_type n, const allocator_type& a)
        : unordered_set(n, hasher(), key_equal(), a) { }
    unordered_set(size_type n, const hasher& hf, const allocator_type& a)
        : unordered_set(n, hf, key_equal(), a) { }
    template<class InputIterator>
    unordered_set(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
        : unordered_set(f, l, n, hasher(), key_equal(), a) { }
    template<class InputIterator>
    unordered_set(InputIterator f, InputIterator l, size_type n, const hasher& hf,
                  const allocator_type& a)
        : unordered_set(f, l, n, hf, key_equal(), a) { }
    unordered_set(initializer_list<value_type> il, size_type n, const allocator_type& a)
        : unordered_set(il, n, hasher(), key_equal(), a) { }
    template<container_compatible_range<value_type> R> unordered_set(from_range_t, R&& rg, size_type n, const allocator_type& a)
        : unordered_set(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } template<container_compatible_range<value_type> R>
    unordered_set(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
        : unordered_set(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }
    unordered_set(initializer_list<value_type> il, size_type n, const hasher& hf,
                  const allocator_type& a)
        : unordered_set(il, n, hf, key_equal(), a) { } ~unordered_set();
    unordered_set& operator=(const unordered_set&); unordered_set& operator=(unordered_set&&)
    noexcept(allocator_traits<Allocator>::is_always_equal::value &&
             is_nothrow_move_assignable_v<Hash> &&
             is_nothrow_move_assignable_v<Pred>);
    unordered_set& operator=(initializer_list<value_type>);
    allocator_type get_allocator() const noexcept;
// iterators
    iterator       begin() noexcept;
    const_iterator begin() const noexcept;
    iterator       end() noexcept;
    const_iterator end() const noexcept;
    const_iterator cbegin() const noexcept;
    const_iterator cend() const noexcept;
// capacity
    [[nodiscard]] bool empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;
// modifiers
    template<class... Args> pair<iterator, bool> emplace(Args&&... args);
    template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
    pair<iterator, bool> insert(value_type&& obj);
    iterator insert(const_iterator hint, const value_type& obj);
    iterator insert(const_iterator hint, value_type&& obj);
    template<class InputIterator> void insert(InputIterator first, InputIterator last); template<container-compatible-range<value_type> R>
    void insert_range(R&& rg);
    void insert(initializer_list<value_type>);
    node_type extract(const_iterator position);
    node_type extract(const key_type& x);
    template<class K> node_type extract(K&& x);
    insert_return_type insert(node_type&& nh);
    iterator           insert(const_iterator hint, node_type&& nh);
    iterator  erase(iterator position);
    iterator  erase(const_iterator position);
    size_type erase(const key_type& k);
    template<class K> size_type erase(K&& x);
    iterator  erase(const_iterator first, const_iterator last);
    void      swap(unordered_set&)
    noexcept(allocator_traits<Allocator>::is_always_equal::value &&
             is_nothrow_swappable_v<Hash> &&
             is_nothrow_swappable_v<Pred>);
    void      clear() noexcept;
    template<class H2, class P2>
    void merge(unordered_set<Key, H2, P2, Allocator>& source);
    template<class H2, class P2>
    void merge(unordered_set<Key, H2, P2, Allocator>&& source);
    template<class H2, class P2>
    void merge(unordered_multiset<Key, H2, P2, Allocator>& source);
    template<class H2, class P2>
    void merge(unordered_multiset<Key, H2, P2, Allocator>&& source);
// observers
    hasher hash_function() const;
    key_equal key_eq() const;
// set operations
    iterator
    const_iterator
    template<class K>
    iterator
    template<class K>
    find(const key_type& k);
    find(const key_type& k) const;
    find(const K& k);
    const_iterator find(const K& k) const;
    size_type        count(const key_type& k) const;
    template<class K>
    size_type      count(const K& k) const;
    bool             contains(const key_type& k) const;
    template<class K>
    bool           contains(const K& k) const;
    pair<iterator, iterator>
    pair<const_iterator, const_iterator>
    template<class K>
// bucket interface
    size_type bucket_count() const noexcept;
    size_type max_bucket_count() const noexcept;
    size_type bucket_size(size_type n) const;
    size_type bucket(const key_type& k) const;
    local_iterator begin(size_type n);
    const_local_iterator begin(size_type n) const;
    local_iterator end(size_type n);
    const_local_iterator end(size_type n) const;
    const_local_iterator cbegin(size_type n) const;
    const_local_iterator cend(size_type n) const;
// hash policy
    float load_factor() const noexcept;
    float max_load_factor() const noexcept;
    void max_load_factor(float z);
    void rehash(size_type n);
    void reserve(size_type n);
};
template<class InputIterator,
         class Hash = hash<iter_value_type<InputIterator>>,
         class Pred = equal_to<iter_value_type<InputIterator>>,
         class Allocator = allocator<iter-value-type<InputIterator>>>
                                     unordered_set(InputIterator, InputIterator, typename see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
                                     -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
         template<ranges::input_range R,
                  class Hash = hash<ranges::range_value_t<R>>,
                  class Pred = equal_to<ranges::range_value_t<R>>,
                  class Allocator = allocator<ranges::range_value_t<R>>>
                          unordered_set(from_range_t, R&&, typename see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
                          equal_range(const key_type& k);
                  equal_range(const key_type& k) const;
                  equal_range(const K& k);
                  pair<const_iterator, const_iterator> equal_range(const K& k) const;
                  pair<iterator, iterator>
                  template<class K>
                  Effects: Constructs an empty unordered_set using the specified hash function, key equality predicate, and allocator, and using at least n buckets. For the default constructor, the number of buckets is implementation-defined. max_load_factor() returns 1.0.
                  Complexity: Constant.
                  -> unordered_set<ranges::range_value_t<R>, Hash, Pred, Allocator>;
                  template<class T, class Hash = hash<T>,
                           class Pred = equal_to<T>, class Allocator = allocator<T>>
                  unordered_set(initializer_list<T>, typename see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
                  -> unordered_set<T, Hash, Pred, Allocator>;
                  template<class InputIterator, class Allocator>
                  unordered_set(InputIterator, InputIterator, typename see below::size_type, Allocator)
                  -> unordered_set<iter_value_type<InputIterator>, hash<iter_value_type <InputIterator>>,
                                   equal_to<iter_value_type <InputIterator>>, Allocator>;
                  template<class InputIterator, class Hash, class Allocator> unordered_set(InputIterator, InputIterator, typename see below::size_type,
                          Hash, Allocator)
                  -> unordered_set<iter-value-type<InputIterator>, Hash,
                                   equal_to<iter-value-type <InputIterator>>, Allocator>;
                  template<ranges::input_range R, class Allocator>
                  unordered_set(from_range_t, R&&, typename see below::size_type, Allocator)
                  -> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
                                   equal_to<ranges::range_value_t<R>>, Allocator>;
                  template<ranges::input_range R, class Allocator>
                  unordered_set(from_range_t, R&&, Allocator)
                  -> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
                                   equal_to<ranges::range_value_t<R>>, Allocator>;
                  template<ranges::input_range R, class Hash, class Allocator> unordered_set(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
                  -> unordered_set<ranges::range_value_t<R>, Hash,
                                   equal_to<ranges::range_value_t<R>>, Allocator>;
                  template<class T, class Allocator>
                  unordered_set(initializer_list<T>, typename see below::size_type, Allocator)
                  -> unordered_set<T, hash<T>, equal_to<T>, Allocator>;
                  template<class T, class Hash, class Allocator>
                  unordered_set(initializer_list<T>, typename see below::size_type, Hash, Allocator)
                  -> unordered_set<T, Hash, equal_to<T>, Allocator>;
}
// A size_type parameter type in an unordered_set deduction guide refers to the size_type member type of the type deduced by the deduction guide.
// 24.5.6.2 Constructors [imprd/set/cmstr]
                  unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
                          const hasher& hf = hasher(),
                          const key_equal& eql = key_equal(),
                          const allocator_type& a = allocator_type());
template<class InputIterator>
unordered_set(InputIterator f, InputIterator l,
              size_type n = see below,
              const hasher& hf = hasher(),
              const key_equal& eql = key_equal(),
              const allocator_type& a = allocator_type());
template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
        size_type n = see below,
        const hasher& hf = hasher(),
        const key_equal& eql = key_equal(),
        const allocator_type& a = allocator_type());
unordered_set(initializer_list<value_type> il, size_type n = see below,
              const hasher& hf = hasher(),
              const key_equal& eql = key_equal(),
              const allocator_type& a = allocator_type());
// Effects: Constructs an empty unordered_set using the specified hash function, key equality predicate, and allocator, and using at least n buckets. If n is not provided, the number of buckets is implementation- defined. Then inserts elements from the range [f, l), rg, or il, respectively. max_load_factor() returns 1.0.
// Complexity: Average case linear, worst case quadratic. 24.5.6.3 Erasure
template<class K, class H, class P, class A, class Predicate>
typename unordered_set<K, H, P, A>::size_type
[unord.set.erasure]
erase_if(unordered_set<K, H, P, A>& c, Predicate pred);
Effects: Equivalent to:
auto original_size = c.size();
for (auto i = c.begin(), last = c.end(); i != last; ) {
    if (pred(*i)) {
        i = c.erase(i);
    } else {
        ++i;
    }
}
return original_size - c.size();
// 24.5.7 Class template unordered_multiset [unord.multiset]
// 24.5.7.1 Overview  [unord.multiset.overview]
//  An unordered_multiset is an unordered associative container that supports equivalent keys (an instance of unordered_multiset may contain multiple copies of the same key value) and in which each element’s key is the element itself. The unordered_multiset class supports forward iterators.
//  An unordered_multiset meets all of the requirements of a container (24.2.2.2), of an allocator-aware container (24.2.2.5), and of an unordered associative container (24.2.8). It provides the operations described in the preceding requirements table for equivalent keys; that is, an unordered_multiset supports the a_eq operations in that table, not the a_uniq operations. For an unordered_multiset<Key> the key type and the value type are both Key. The iterator and const_iterator types are both constant iterator types. It is unspecified whether they are the same type.
// Subclause 24.5.7 only describes operations on unordered_multiset that are not described in one of the requirement tables, or for which there is additional semantic information.
namespace std {
template<class Key,
         class Hash = hash<Key>,
         class Pred = equal_to<Key>,
         class Allocator = allocator<Key>>
class unordered_multiset {
public:
// types
    using key_type = Key;
    using value_type = Key;
    using hasher = Hash;
    using key_equal = Pred;
    using allocator_type = Allocator;
    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 size_type = implementation_defined ; // see 24.2
    using difference_type = implementation_defined ; // see 24.2
    using iterator = implementation_defined ; // see 24.2
    using const_iterator = implementation_defined ; // see 24.2
    using local_iterator  = implementation_defined ; // see 24.2
    using const_local_iterator  = implementation_defined ; // see 24.2
    using node_type = unspecified ;
// 24.5.7.2, construct/copy/destroy unordered_multiset();
    explicit unordered_multiset(size_type n,
                                const hasher& hf = hasher(),
                                const key_equal& eql = key_equal(),
                                const allocator_type& a = allocator_type());
    template<class InputIterator>
    unordered_multiset(InputIterator f, InputIterator l,
                       size_type n = see below,
                       const hasher& hf = hasher(),
                       const key_equal& eql = key_equal(),
                       const allocator_type& a = allocator_type());
    template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
            size_type n = see_below,
            const hasher& hf = hasher(),
            const key_equal& eql = key_equal(),
            const allocator_type& a = allocator_type());
    unordered_multiset(const unordered_multiset&);
    unordered_multiset(unordered_multiset&&);
    explicit unordered_multiset(const Allocator&);
    unordered_multiset(const unordered_multiset&, const type_identity_t<Allocator>&);
    unordered_multiset(unordered_multiset&&, const type_identity_t<Allocator>&);
    unordered_multiset(initializer_list<value_type> il,
                       size_type n = see_below,
                       const hasher& hf = hasher(),
                       const key_equal& eql = key_equal(),
                       const allocator_type& a = allocator_type());
    unordered_multiset(size_type n, const allocator_type& a)
        : unordered_multiset(n, hasher(), key_equal(), a) { }
    unordered_multiset(size_type n, const hasher& hf, const allocator_type& a)
        : unordered_multiset(n, hf, key_equal(), a) { }
    template<class InputIterator>
    unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
        : unordered_multiset(f, l, n, hasher(), key_equal(), a) { }
    template<class InputIterator>
    unordered_multiset(InputIterator f, InputIterator l, size_type n, const hasher& hf,
                       const allocator_type& a)
        : unordered_multiset(f, l, n, hf, key_equal(), a) { } template<container_compatible_range<value_type> R>
    unordered_multiset(from_range_t, R&& rg, size_type n, const allocator_type& a)
        : unordered_multiset(from_range, std::forward<R>(rg),
                             n, hasher(), key_equal(), a) { }
    template<container-compatible-range<value_type> R> unordered_multiset(from_range_t, R&& rg, size_type n, const hasher& hf,
            const allocator_type& a)
        : unordered_multiset(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }
    unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a)
        : unordered_multiset(il, n, hasher(), key_equal(), a) { }
    unordered_multiset(initializer_list<value_type> il, size_type n, const hasher& hf,
                       const allocator_type& a)
        : unordered_multiset(il, n, hf, key_equal(), a) { } ~unordered_multiset();
    unordered_multiset& operator=(const unordered_multiset&); unordered_multiset& operator=(unordered_multiset&&)
    noexcept(allocator_traits<Allocator>::is_always_equal::value &&
             is_nothrow_move_assignable_v<Hash> &&
             is_nothrow_move_assignable_v<Pred>);
    unordered_multiset& operator=(initializer_list<value_type>);
    allocator_type get_allocator() const noexcept;
// iterators
    iterator       begin() noexcept;
    const_iterator begin() const noexcept;
    iterator       end() noexcept;
    const_iterator end() const noexcept;
    const_iterator cbegin() const noexcept;
    const_iterator cend() const noexcept;
// capacity
    [[nodiscard]] bool empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;
// modifiers
    template<class... Args> iterator emplace(Args&&... args);
    template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj);
    iterator insert(value_type&& obj);
    iterator insert(const_iterator hint, const value_type& obj);
    iterator insert(const_iterator hint, value_type&& obj);
    template<class InputIterator> void insert(InputIterator first, InputIterator last); template<container-compatible-range<value_type> R>
    void insert_range(R&& rg);
    void insert(initializer_list<value_type>);
    node_type extract(const_iterator position);
    node_type extract(const key_type& x);
    template<class K> node_type extract(K&& x);
    iterator insert(node_type&& nh);
    iterator insert(const_iterator hint, node_type&& nh);
    iterator  erase(iterator position);
    iterator  erase(const_iterator position);
    size_type erase(const key_type& k);
    template<class K> size_type erase(K&& x);
    iterator  erase(const_iterator first, const_iterator last);
    void      swap(unordered_multiset&)
    noexcept(allocator_traits<Allocator>::is_always_equal::value &&
             is_nothrow_swappable_v<Hash> &&
             is_nothrow_swappable_v<Pred>);
    void      clear() noexcept;
    template<class H2, class P2>
    void merge(unordered_multiset<Key, H2, P2, Allocator>& source);
    template<class H2, class P2>
    void merge(unordered_multiset<Key, H2, P2, Allocator>&& source);
    template<class H2, class P2>
    void merge(unordered_set<Key, H2, P2, Allocator>& source);
    template<class H2, class P2>
    void merge(unordered_set<Key, H2, P2, Allocator>&& source);
// observers
    hasher hash_function() const;
    key_equal key_eq() const;
// set operations
    iterator
    const_iterator
    template<class K>
    iterator
    template<class K>
    find(const key_type& k);
    find(const key_type& k) const;
    find(const K& k);
    const_iterator find(const K& k) const;
    size_type        count(const key_type& k) const;
    template<class K>
    size_type      count(const K& k) const;
    bool             contains(const key_type& k) const;
    template<class K>
    bool           contains(const K& k) const;
    pair<iterator, iterator>
    pair<const_iterator, const_iterator>
    template<class K>
// bucket interface
    size_type bucket_count() const noexcept;
    size_type max_bucket_count() const noexcept;
    size_type bucket_size(size_type n) const;
    size_type bucket(const key_type& k) const;
    local_iterator begin(size_type n);
    const_local_iterator begin(size_type n) const;
    local_iterator end(size_type n);
    const_local_iterator end(size_type n) const;
    const_local_iterator cbegin(size_type n) const;
    const_local_iterator cend(size_type n) const;
// hash policy
    float load_factor() const noexcept;
    float max_load_factor() const noexcept;
    void max_load_factor(float z);
    void rehash(size_type n);
    void reserve(size_type n);
};
template<class InputIterator,
         class Hash = hash<iter_value_type<InputIterator>>,
         class Pred = equal_to<iter_value_type<InputIterator>>,
         class Allocator = allocator<iter-value-type<InputIterator>>>
                                     unordered_multiset(InputIterator, InputIterator, see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
                                     -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
         template<ranges::input_range R,
                  class Hash = hash<ranges::range_value_t<R>>,
                  class Pred = equal_to<ranges::range_value_t<R>>,
                  class Allocator = allocator<ranges::range_value_t<R>>>
                          unordered_multiset(from_range_t, R&&, typename see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
                          equal_range(const key_type& k);
                  equal_range(const key_type& k) const;
                  equal_range(const K& k);
                  pair<const_iterator, const_iterator> equal_range(const K& k) const;
                  pair<iterator, iterator>
                  template<class K>
// Effects: Constructs an empty unordered_multiset using the specified hash function, key equality predicate, and allocator, and using at least n buckets. For the default constructor, the number of buckets is implementation-defined. max_load_factor() returns 1.0. Complexity: Constant.
                  -> unordered_multiset<ranges::range_value_t<R>, Hash, Pred, Allocator>;
                  template<class T, class Hash = hash<T>,
                           class Pred = equal_to<T>, class Allocator = allocator<T>>
                  unordered_multiset(initializer_list<T>, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
                  -> unordered_multiset<T, Hash, Pred, Allocator>;
                  template<class InputIterator, class Allocator>
                  unordered_multiset(InputIterator, InputIterator, typename see below::size_type, Allocator)
                  -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
                                        equal_to<iter-value-type <InputIterator>>, Allocator>;
                  template<class InputIterator, class Hash, class Allocator> unordered_multiset(InputIterator, InputIterator, typename see below::size_type,
                          Hash, Allocator)
                  -> unordered_multiset<iter-value-type<InputIterator>, Hash,
                                        equal_to<iter-value-type <InputIterator>>, Allocator>;
                  template<ranges::input_range R, class Allocator>
                  unordered_multiset(from_range_t, R&&, typename see_below::size_type, Allocator)
                  -> unordered_multiset<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
                                        equal_to<ranges::range_value_t<R>>, Allocator>;
                  template<ranges::input_range R, class Allocator>
                  unordered_multiset(from_range_t, R&&, Allocator)
                  -> unordered_multiset<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
                                        equal_to<ranges::range_value_t<R>>, Allocator>;
                  template<ranges::input_range R, class Hash, class Allocator> unordered_multiset(from_range_t, R&&, typename see_below::size_type, Hash, Allocator)
                  -> unordered_multiset<ranges::range_value_t<R>, Hash, equal_to<ranges::range_value_t<R>>,
                                        Allocator>;
                  template<class T, class Allocator>
                  unordered_multiset(initializer_list<T>, typename see_below::size_type, Allocator)
                  -> unordered_multiset<T, hash<T>, equal_to<T>, Allocator>;
                  template<class T, class Hash, class Allocator>
                  unordered_multiset(initializer_list<T>, typename see_below::size_type, Hash, Allocator)
                  -> unordered_multiset<T, Hash, equal_to<T>, Allocator>;
}
//  A size_type parameter type in an unordered_multiset deduction guide refers to the size_type member type of the type deduced by the deduction guide.
// 24.5.7.2 Constructors [unord.multiset.cnstr]
                  unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
                          const hasher& hf = hasher(),
                          const key_equal& eql = key_equal(),
                          const allocator_type& a = allocator_type());
template<class InputIterator>
unordered_multiset(InputIterator f, InputIterator l,
                   size_type n = see_below,
                   const hasher& hf = hasher(),
                   const key_equal& eql = key_equal(),
                   const allocator_type& a = allocator_type());
template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
        size_type n = see_below,
        const hasher& hf = hasher(),
        const key_equal& eql = key_equal(),
        const allocator_type& a = allocator_type());
unordered_multiset(initializer_list<value_type> il, size_type n = see_below,
                   const hasher& hf = hasher(),
                   const key_equal& eql = key_equal(),
                   const allocator_type& a = allocator_type());
// Effects: Constructs an empty unordered_multiset using the specified hash function, key equality predicate, and allocator, and using at least n buckets. If n is not provided, the number of buckets is implementation-defined. Then inserts elements from the range [f,l), rg, or il, respectively. max_- load_factor() returns 1.0.
// Complexity: Average case linear, worst case quadratic.
// 24.5.7.3 Erasure [unord.multiset.erasrure]
template<class K, class H, class P, class A, class Predicate>
typename unordered_multiset<K, H, P, A>::size_type
erase_if(unordered_multiset<K, H, P, A>& c, Predicate pred);
// Effects: Equivalent to:
auto original_size = c.size();
for (auto i = c.begin(), last = c.end(); i != last; ) {
    if (pred(*i)) {
        i = c.erase(i);
    } else {
        ++i;
    }
}
return original_size - c.size();

int main() {
    cout  <<  n4910 << endl;
    return EXIT_SUCCESS;
}
```

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

```ubuntu:bash
$ clang++ p925.cpp -std=03 -o p925l -I. -Wall
p925.cpp:1:1: error: expected unqualified-id
```c++:p925.cpp
^
In file included from p925.cpp:11:
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 \
 ^
p925.cpp:23:24: error: expected unqualified-id
                class T,
                       ^
p925.cpp:29:24: error: expected unqualified-id
                class T,
                       ^
p925.cpp:35:32: error: no template named 'unordered_map'
         bool operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
                               ^
p925.cpp:36:32: error: no template named 'unordered_map'
                         const unordered_map<Key, T, Hash, Pred, Alloc>& b);
                               ^
p925.cpp:38:32: error: no template named 'unordered_multimap'
         bool operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
                               ^
p925.cpp:39:32: error: no template named 'unordered_multimap'
                         const unordered_multimap<Key, T, Hash, Pred, Alloc>& b);
                               ^
p925.cpp:41:20: error: no template named 'unordered_map'
         void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
                   ^
p925.cpp:42:20: error: no template named 'unordered_map'
                   unordered_map<Key, T, Hash, Pred, Alloc>& y)
                   ^
p925.cpp:42:64: error: expected ';' at end of declaration
                   unordered_map<Key, T, Hash, Pred, Alloc>& y)
                                                               ^
                                                               ;
p925.cpp:43:12: error: C++ requires a type specifier for all declarations
           noexcept(noexcept(x.swap(y)));
           ^
p925.cpp:43:30: error: use of undeclared identifier 'x'
           noexcept(noexcept(x.swap(y)));
                             ^
p925.cpp:43:37: error: use of undeclared identifier 'y'
           noexcept(noexcept(x.swap(y)));
                                    ^
p925.cpp:45:20: error: no template named 'unordered_multimap'
         void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
                   ^
p925.cpp:46:20: error: no template named 'unordered_multimap'
                   unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
                   ^
p925.cpp:46:69: error: expected ';' at end of declaration
                   unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
                                                                    ^
                                                                    ;
p925.cpp:47:12: error: C++ requires a type specifier for all declarations
           noexcept(noexcept(x.swap(y)));
           ^
p925.cpp:47:30: error: use of undeclared identifier 'x'
           noexcept(noexcept(x.swap(y)));
                             ^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
20 errors generated.
$ clang++ p925.cpp -std=2b -o p925l -I. -Wall
p925.cpp:1:1: error: expected unqualified-id
```c++:p925.cpp
^
p925.cpp:23:24: error: expected unqualified-id
                class T,
                       ^
p925.cpp:29:24: error: expected unqualified-id
                class T,
                       ^
p925.cpp:54:3: error: extraneous closing brace ('}')
} }
  ^
p925.cpp:62:26: error: use of undeclared identifier 'polymorphic_allocator'
                         polymorphic_allocator<pair<const Key, T>>>;
                         ^
p925.cpp:69:33: error: use of undeclared identifier 'polymorphic_allocator'
                                polymorphic_allocator<pair<const Key, T>>>;
                                ^
p925.cpp:75:23: error: expected unqualified-id
           class Hash = hash<Key>,
                      ^
p925.cpp:80:23: error: expected unqualified-id
           class Hash = hash<Key>,
                      ^
p925.cpp:85:27: error: no template named 'unordered_set'; did you mean 'unordered_map'?
    bool operator==(const unordered_set<Key, Hash, Pred, Alloc>& a,
                          ^~~~~~~~~~~~~
                          unordered_map
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/unordered_map.h:102:11: note: 'unordered_map' declared here
    class unordered_map
          ^
p925.cpp:86:27: error: no template named 'unordered_set'; did you mean 'unordered_map'?
                    const unordered_set<Key, Hash, Pred, Alloc>& b);
                          ^~~~~~~~~~~~~
                          unordered_map
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/unordered_map.h:102:11: note: 'unordered_map' declared here
    class unordered_map
          ^
p925.cpp:88:27: error: no template named 'unordered_multiset'; did you mean 'unordered_multimap'?
    bool operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
                          ^~~~~~~~~~~~~~~~~~
                          unordered_multimap
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/unordered_map.h:1249:11: note: 'unordered_multimap' declared here
    class unordered_multimap
          ^
p925.cpp:89:27: error: no template named 'unordered_multiset'; did you mean 'unordered_multimap'?
                    const unordered_multiset<Key, Hash, Pred, Alloc>& b);
                          ^~~~~~~~~~~~~~~~~~
                          unordered_multimap
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/unordered_map.h:1249:11: note: 'unordered_multimap' declared here
    class unordered_multimap
          ^
p925.cpp:91:15: error: no template named 'unordered_set'; did you mean 'unordered_map'?
    void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
              ^~~~~~~~~~~~~
              unordered_map
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/unordered_map.h:102:11: note: 'unordered_map' declared here
    class unordered_map
          ^
p925.cpp:92:15: error: no template named 'unordered_set'; did you mean 'unordered_map'?
              unordered_set<Key, Hash, Pred, Alloc>& y)
              ^~~~~~~~~~~~~
              unordered_map
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/unordered_map.h:102:11: note: 'unordered_map' declared here
    class unordered_map
          ^
p925.cpp:95:15: error: no template named 'unordered_multiset'; did you mean 'unordered_multimap'?
    void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
              ^~~~~~~~~~~~~~~~~~
              unordered_multimap
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/unordered_map.h:1249:11: note: 'unordered_multimap' declared here
    class unordered_multimap
          ^
p925.cpp:96:15: error: no template named 'unordered_multiset'; did you mean 'unordered_multimap'?
              unordered_multiset<Key, Hash, Pred, Alloc>& y)
              ^~~~~~~~~~~~~~~~~~
              unordered_multimap
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/unordered_map.h:1249:11: note: 'unordered_multimap' declared here
    class unordered_multimap
          ^
p925.cpp:99:14: error: no template named 'unordered_set'; did you mean 'unordered_map'?
    typename unordered_set<K, H, P, A>::size_type
             ^~~~~~~~~~~~~
             unordered_map
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/unordered_map.h:102:11: note: 'unordered_map' declared here
    class unordered_map
          ^
p925.cpp:100:16: error: no template named 'unordered_set'; did you mean 'unordered_map'?
      erase_if(unordered_set<K, H, P, A>& c, Predicate pred);
               ^~~~~~~~~~~~~
               unordered_map
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/unordered_map.h:102:11: note: 'unordered_map' declared here
    class unordered_map
          ^
p925.cpp:102:14: error: no template named 'unordered_multiset'; did you mean 'unordered_multimap'?
    typename unordered_multiset<K, H, P, A>::size_type
             ^~~~~~~~~~~~~~~~~~
             unordered_multimap
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/unordered_map.h:1249:11: note: 'unordered_multimap' declared here
    class unordered_multimap
          ^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
20 errors generated.

$ g++ p925.cpp -std=03 -o p925g -I. -Wall
p925.cpp:1:1: error: stray '`' in program
    1 | ```c++:p925.cpp
      | ^
p925.cpp:1:2: error: stray '`' in program
    1 | ```c++:p925.cpp
      |  ^
p925.cpp:1:3: error: stray '`' in program
    1 | ```c++:p925.cpp
      |   ^
In file included from /usr/local/include/c++/12.1.0/atomic:38,
                 from N4910.h:11,
                 from p925.cpp:11:
/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 \
      |  ^~~~~
p925.cpp:43:12: warning: identifier 'noexcept' is a keyword in C++11 [-Wc++11-compat]
   43 |            noexcept(noexcept(x.swap(y)));
      |            ^~~~~~~~
p925.cpp:337:18: error: stray '\' in program
  337 | template<ranges::\tcode{input_range} R, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Allocator)
      |                  ^
p925.cpp:897:252: error: too many decimal points in number
  897 | efault constructor, the number of buckets is implementation-defined. max_load_factor() returns 1.0.
      |                                                                                                ^~~~

p925.cpp:1:4: error: 'c' does not name a type
    1 | ```c++:p925.cpp
      |    ^
p925.cpp:23:24: error: expected unqualified-id before ',' token
   23 |                 class T,
      |                        ^
p925.cpp:24:17: error: expected unqualified-id before 'class'
   24 |                 class Hash = hash<Key>,
      |                 ^~~~~
p925.cpp:29:24: error: expected unqualified-id before ',' token
   29 |                 class T,
      |                        ^
p925.cpp:30:17: error: expected unqualified-id before 'class'
   30 |                 class Hash = hash<Key>,
      |                 ^~~~~
p925.cpp:35:32: error: 'unordered_map' does not name a type
   35 |          bool operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
      |                                ^~~~~~~~~~~~~
p925.cpp:35:45: error: expected ',' or '...' before '<' token
   35 |          bool operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
      |                                             ^
p925.cpp:35:15: error: 'bool std::operator==(int)' must have an argument of class or enumerated type
   35 |          bool operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
      |               ^~~~~~~~
p925.cpp:38:32: error: 'unordered_multimap' does not name a type
   38 |          bool operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
      |                                ^~~~~~~~~~~~~~~~~~
p925.cpp:38:50: error: expected ',' or '...' before '<' token
   38 |          bool operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
      |                                                  ^
p925.cpp:38:15: error: 'bool std::operator==(int)' must have an argument of class or enumerated type
   38 |          bool operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
      |               ^~~~~~~~
p925.cpp:41:15: error: variable or field 'swap' declared void
   41 |          void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
      |               ^~~~
p925.cpp:41:20: error: 'unordered_map' was not declared in this scope
   41 |          void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
      |                    ^~~~~~~~~~~~~
p925.cpp:41:20: note: 'std::unordered_map' is only available from C++11 onwards
p925.cpp:41:37: error: expected primary-expression before ',' token
   41 |          void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
      |                                     ^
p925.cpp:41:40: error: expected primary-expression before ',' token
   41 |          void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
      |                                        ^
p925.cpp:41:46: error: expected primary-expression before ',' token
   41 |          void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
      |                                              ^
p925.cpp:41:52: error: expected primary-expression before ',' token
   41 |          void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
      |                                                    ^
p925.cpp:41:59: error: expected primary-expression before '>' token
   41 |          void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
      |                                                           ^
p925.cpp:41:62: error: 'x' was not declared in this scope
   41 |          void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
      |                                                              ^
p925.cpp:42:20: error: 'unordered_map' was not declared in this scope
   42 |                    unordered_map<Key, T, Hash, Pred, Alloc>& y)
      |                    ^~~~~~~~~~~~~
p925.cpp:42:20: note: 'std::unordered_map' is only available from C++11 onwards
p925.cpp:42:37: error: expected primary-expression before ',' token
   42 |                    unordered_map<Key, T, Hash, Pred, Alloc>& y)
      |                                     ^
p925.cpp:42:40: error: expected primary-expression before ',' token
   42 |                    unordered_map<Key, T, Hash, Pred, Alloc>& y)
      |                                        ^
p925.cpp:42:46: error: expected primary-expression before ',' token
   42 |                    unordered_map<Key, T, Hash, Pred, Alloc>& y)
      |                                              ^
p925.cpp:42:52: error: expected primary-expression before ',' token
   42 |                    unordered_map<Key, T, Hash, Pred, Alloc>& y)
      |                                                    ^
p925.cpp:42:59: error: expected primary-expression before '>' token
   42 |                    unordered_map<Key, T, Hash, Pred, Alloc>& y)
      |                                                           ^
p925.cpp:42:62: error: 'y' was not declared in this scope
   42 |                    unordered_map<Key, T, Hash, Pred, Alloc>& y)
      |                                                              ^
p925.cpp:45:15: error: variable or field 'swap' declared void
   45 |          void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
      |               ^~~~
p925.cpp:45:20: error: 'unordered_multimap' was not declared in this scope
   45 |          void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
      |                    ^~~~~~~~~~~~~~~~~~
p925.cpp:45:20: note: 'std::unordered_multimap' is only available from C++11 onwards
p925.cpp:45:42: error: expected primary-expression before ',' token
   45 |          void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
      |                                          ^
p925.cpp:45:45: error: expected primary-expression before ',' token
   45 |          void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
      |                                             ^
p925.cpp:45:51: error: expected primary-expression before ',' token
   45 |          void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
      |                                                   ^
p925.cpp:45:57: error: expected primary-expression before ',' token
   45 |          void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
      |                                                         ^
p925.cpp:45:64: error: expected primary-expression before '>' token
   45 |          void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
      |                                                                ^
p925.cpp:45:67: error: 'x' was not declared in this scope
   45 |          void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
      |                                                                   ^
p925.cpp:46:20: error: 'unordered_multimap' was not declared in this scope
   46 |                    unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
      |                    ^~~~~~~~~~~~~~~~~~
p925.cpp:46:20: note: 'std::unordered_multimap' is only available from C++11 onwards
p925.cpp:46:42: error: expected primary-expression before ',' token
   46 |                    unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
      |                                          ^
p925.cpp:46:45: error: expected primary-expression before ',' token
   46 |                    unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
      |                                             ^
p925.cpp:46:51: error: expected primary-expression before ',' token
   46 |                    unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
      |                                                   ^
p925.cpp:46:57: error: expected primary-expression before ',' token
   46 |                    unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
      |                                                         ^
p925.cpp:46:64: error: expected primary-expression before '>' token
   46 |                    unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
      |                                                                ^
p925.cpp:46:67: error: 'y' was not declared in this scope
   46 |                    unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
      |                                                                   ^
p925.cpp:49:19: error: expected nested-name-specifier before 'unordered_map'
   49 |          typename unordered_map<K, T, H, P, A>::size_type
      |                   ^~~~~~~~~~~~~
p925.cpp:49:32: error: expected initializer before '<' token
   49 |          typename unordered_map<K, T, H, P, A>::size_type
      |                                ^
p925.cpp:52:19: error: expected nested-name-specifier before 'unordered_multimap'
   52 |          typename unordered_multimap<K, T, H, P, A>::size_type
      |                   ^~~~~~~~~~~~~~~~~~
p925.cpp:52:37: error: expected initializer before '<' token
   52 |          typename unordered_multimap<K, T, H, P, A>::size_type
      |                                     ^
p925.cpp:54:3: error: expected declaration before '}' token
   54 | } }
      |   ^
p925.cpp:58:25: error: 'hash' does not name a type
   58 |            class Hash = hash<Key>,
      |                         ^~~~
p925.cpp:58:29: error: expected '>' before '<' token
   58 |            class Hash = hash<Key>,
      |                             ^
p925.cpp:62:68: error: expected unqualified-id before ';' token
   62 |                          polymorphic_allocator<pair<const Key, T>>>;
      |                                                                    ^
p925.cpp:65:25: error: 'hash' does not name a type
   65 |            class Hash = hash<Key>,
      |                         ^~~~
p925.cpp:65:29: error: expected '>' before '<' token
   65 |            class Hash = hash<Key>,
      |                             ^
p925.cpp:69:75: error: expected unqualified-id before ';' token
   69 |                                 polymorphic_allocator<pair<const Key, T>>>;
      |                                                                           ^
p925.cpp:75:23: error: expected unqualified-id before '=' token
   75 |            class Hash = hash<Key>,
      |                       ^
p925.cpp:80:23: error: expected unqualified-id before '=' token
   80 |            class Hash = hash<Key>,
      |                       ^
p925.cpp:85:27: error: 'unordered_set' does not name a type
   85 |     bool operator==(const unordered_set<Key, Hash, Pred, Alloc>& a,
      |                           ^~~~~~~~~~~~~
p925.cpp:85:40: error: expected ',' or '...' before '<' token
   85 |     bool operator==(const unordered_set<Key, Hash, Pred, Alloc>& a,
      |                                        ^
p925.cpp:85:10: error: 'bool pmr::std::operator==(int)' must have an argument of class or enumerated type
   85 |     bool operator==(const unordered_set<Key, Hash, Pred, Alloc>& a,
      |          ^~~~~~~~
p925.cpp:88:27: error: 'unordered_multiset' does not name a type
   88 |     bool operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
      |                           ^~~~~~~~~~~~~~~~~~
p925.cpp:88:45: error: expected ',' or '...' before '<' token
   88 |     bool operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
      |                                             ^
p925.cpp:88:10: error: 'bool pmr::std::operator==(int)' must have an argument of class or enumerated type
   88 |     bool operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
      |          ^~~~~~~~
p925.cpp:91:10: error: variable or field 'swap' declared void
   91 |     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
      |          ^~~~
p925.cpp:91:15: error: 'unordered_set' was not declared in this scope
   91 |     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
      |               ^~~~~~~~~~~~~
p925.cpp:91:15: note: 'std::unordered_set' is only available from C++11 onwards
p925.cpp:91:32: error: expected primary-expression before ',' token
   91 |     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
      |                                ^
p925.cpp:91:38: error: expected primary-expression before ',' token
   91 |     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
      |                                      ^
p925.cpp:91:44: error: expected primary-expression before ',' token
   91 |     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
      |                                            ^
p925.cpp:91:51: error: expected primary-expression before '>' token
   91 |     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
      |                                                   ^
p925.cpp:91:54: error: 'x' was not declared in this scope
   91 |     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
      |                                                      ^
p925.cpp:92:15: error: 'unordered_set' was not declared in this scope
   92 |               unordered_set<Key, Hash, Pred, Alloc>& y)
      |               ^~~~~~~~~~~~~
p925.cpp:92:15: note: 'std::unordered_set' is only available from C++11 onwards
p925.cpp:92:32: error: expected primary-expression before ',' token
   92 |               unordered_set<Key, Hash, Pred, Alloc>& y)
      |                                ^
p925.cpp:92:38: error: expected primary-expression before ',' token
   92 |               unordered_set<Key, Hash, Pred, Alloc>& y)
      |                                      ^
p925.cpp:92:44: error: expected primary-expression before ',' token
   92 |               unordered_set<Key, Hash, Pred, Alloc>& y)
      |                                            ^
p925.cpp:92:51: error: expected primary-expression before '>' token
   92 |               unordered_set<Key, Hash, Pred, Alloc>& y)
      |                                                   ^
p925.cpp:92:54: error: 'y' was not declared in this scope; did you mean 'yn'?
   92 |               unordered_set<Key, Hash, Pred, Alloc>& y)
      |                                                      ^
      |                                                      yn
p925.cpp:95:10: error: variable or field 'swap' declared void
   95 |     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
      |          ^~~~
p925.cpp:95:15: error: 'unordered_multiset' was not declared in this scope
   95 |     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
      |               ^~~~~~~~~~~~~~~~~~
p925.cpp:95:15: note: 'std::unordered_multiset' is only available from C++11 onwards
p925.cpp:95:37: error: expected primary-expression before ',' token
   95 |     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
      |                                     ^
p925.cpp:95:43: error: expected primary-expression before ',' token
   95 |     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
      |                                           ^
p925.cpp:95:49: error: expected primary-expression before ',' token
   95 |     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
      |                                                 ^
p925.cpp:95:56: error: expected primary-expression before '>' token
   95 |     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
      |                                                        ^
p925.cpp:95:59: error: 'x' was not declared in this scope
   95 |     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
      |                                                           ^
p925.cpp:96:15: error: 'unordered_multiset' was not declared in this scope
   96 |               unordered_multiset<Key, Hash, Pred, Alloc>& y)
      |               ^~~~~~~~~~~~~~~~~~
p925.cpp:96:15: note: 'std::unordered_multiset' is only available from C++11 onwards
p925.cpp:96:37: error: expected primary-expression before ',' token
   96 |               unordered_multiset<Key, Hash, Pred, Alloc>& y)
      |                                     ^
p925.cpp:96:43: error: expected primary-expression before ',' token
   96 |               unordered_multiset<Key, Hash, Pred, Alloc>& y)
      |                                           ^
p925.cpp:96:49: error: expected primary-expression before ',' token
   96 |               unordered_multiset<Key, Hash, Pred, Alloc>& y)
      |                                                 ^
p925.cpp:96:56: error: expected primary-expression before '>' token
   96 |               unordered_multiset<Key, Hash, Pred, Alloc>& y)
      |                                                        ^
p925.cpp:96:59: error: 'y' was not declared in this scope; did you mean 'yn'?
   96 |               unordered_multiset<Key, Hash, Pred, Alloc>& y)
      |                                                           ^
      |                                                           yn
p925.cpp:99:14: error: expected nested-name-specifier before 'unordered_set'
   99 |     typename unordered_set<K, H, P, A>::size_type
      |              ^~~~~~~~~~~~~
p925.cpp:99:27: error: expected initializer before '<' token
   99 |     typename unordered_set<K, H, P, A>::size_type
      |                           ^
p925.cpp:102:14: error: expected nested-name-specifier before 'unordered_multiset'
  102 |     typename unordered_multiset<K, H, P, A>::size_type
      |              ^~~~~~~~~~~~~~~~~~
p925.cpp:102:32: error: expected initializer before '<' token
  102 |     typename unordered_multiset<K, H, P, A>::size_type
      |                                ^
p925.cpp:106:25: error: 'hash' does not name a type; did you mean 'Hash'?
  106 |            class Hash = hash<Key>,
      |                         ^~~~
      |                         Hash
p925.cpp:106:29: error: expected '>' before '<' token
  106 |            class Hash = hash<Key>,
      |                             ^
p925.cpp:109:73: error: expected unqualified-id before ';' token
  109 |                                              polymorphic_allocator<Key>>;
      |                                                                         ^
p925.cpp:111:25: error: 'hash' does not name a type; did you mean 'Hash'?
  111 |            class Hash = hash<Key>,
      |                         ^~~~
      |                         Hash
p925.cpp:111:29: error: expected '>' before '<' token
  111 |            class Hash = hash<Key>,
      |                             ^
p925.cpp:114:90: error: expected unqualified-id before ';' token
  114 |                                                               polymorphic_allocator<Key>>;
      |                                                                                          ^
p925.cpp:120:1: error: 'tables' does not name a type
  120 | tables, or for which there is additional semantic information.
      | ^~~~~~
p925.cpp:131:9: error: expected nested-name-specifier before 'key_type'
  131 |   using key_type = Key;
      |         ^~~~~~~~
p925.cpp:132:9: error: expected nested-name-specifier before 'mapped_type'
  132 |   using mapped_type = T;
      |         ^~~~~~~~~~~
p925.cpp:133:9: error: expected nested-name-specifier before 'value_type'
  133 |   using value_type = pair<const Key, T>;
      |         ^~~~~~~~~~
p925.cpp:134:9: error: expected nested-name-specifier before 'hasher'
  134 |   using hasher = Hash;
      |         ^~~~~~
p925.cpp:135:9: error: expected nested-name-specifier before 'key_equal'
  135 |   using key_equal = Pred;
      |         ^~~~~~~~~
p925.cpp:136:9: error: expected nested-name-specifier before 'allocator_type'
  136 |   using allocator_type = Allocator;
      |         ^~~~~~~~~~~~~~
p925.cpp:137:9: error: expected nested-name-specifier before 'pointer'
  137 |   using pointer = typename allocator_traits<Allocator>::pointer;
      |         ^~~~~~~
p925.cpp:138:9: error: expected nested-name-specifier before 'const_pointer'
  138 |   using const_pointer = typename allocator_traits<Allocator>::const_pointer;
      |         ^~~~~~~~~~~~~
p925.cpp:139:9: error: expected nested-name-specifier before 'reference'
  139 |   using reference  = value_type&;
      |         ^~~~~~~~~
p925.cpp:140:9: error: expected nested-name-specifier before 'const_reference'
  140 |   using const_reference = const value_type&;
      |         ^~~~~~~~~~~~~~~
p925.cpp:141:9: error: expected nested-name-specifier before 'size_type'
  141 |   using size_type = implementation_defined ; // see 24.2
      |         ^~~~~~~~~
p925.cpp:142:9: error: expected nested-name-specifier before 'difference_type'
  142 |   using difference_type = implementation_defined ; // see 24.2
      |         ^~~~~~~~~~~~~~~
p925.cpp:143:9: error: expected nested-name-specifier before 'iterator'
  143 |   using iterator = implementation_defined ; // see 24.2
      |         ^~~~~~~~
p925.cpp:144:9: error: expected nested-name-specifier before 'const_iterator'
  144 |   using const_iterator = implementation_defined ; // see 24.2
      |         ^~~~~~~~~~~~~~
p925.cpp:145:9: error: expected nested-name-specifier before 'local_iterator'
  145 |   using local_iterator = implementation_defined ; // see 24.2
      |         ^~~~~~~~~~~~~~
p925.cpp:146:9: error: expected nested-name-specifier before 'const_local_iterator'
  146 |   using const_local_iterator = implementation_defined ; // see 24.2
      |         ^~~~~~~~~~~~~~~~~~~~
p925.cpp:147:9: error: expected nested-name-specifier before 'node_type'
  147 |   using node_type = unspecified;
      |         ^~~~~~~~~
p925.cpp:148:9: error: expected nested-name-specifier before 'insert_return_type'
  148 |   using insert_return_type = insert-return-type<iterator, node_type>; // // 24.5.4.2, construct/copy/destroy
      |         ^~~~~~~~~~~~~~~~~~
p925.cpp:150:33: error: expected ')' before 'n'
  150 | explicit unordered_map(size_type n,
      |                       ~         ^~
      |                                 )
p925.cpp:155:49: error: 'size_type' has not been declared
  155 | unordered_map(InputIterator f, InputIterator l, size_type n = see below,
      |                                                 ^~~~~~~~~
p925.cpp:156:23: error: 'hasher' does not name a type; did you mean 'Hash'?
  156 |                 const hasher& hf = hasher(),
      |                       ^~~~~~
      |                       Hash
p925.cpp:157:23: error: 'key_equal' does not name a type
  157 |                 const key_equal& eql = key_equal(),
      |                       ^~~~~~~~~
p925.cpp:158:23: error: 'allocator_type' does not name a type
  158 |                 const allocator_type& a = allocator_type());
      |                       ^~~~~~~~~~~~~~
p925.cpp:159:10: error: 'container' has not been declared
  159 | template<container-compatible-range<value_type> R> unordered_map(from_range_t, R&& rg, size_type n = see below,
      |          ^~~~~~~~~
p925.cpp:159:19: error: expected '>' before '-' token
  159 | template<container-compatible-range<value_type> R> unordered_map(from_range_t, R&& rg, size_type n = see below,
      |                   ^
p925.cpp:159:78: error: expected ')' before ',' token
  159 | template<container-compatible-range<value_type> R> unordered_map(from_range_t, R&& rg, size_type n = see below,
      |                                                                 ~            ^
      |                                                                              )
p925.cpp:163:28: error: expected ',' or '...' before '&&' token
  163 | unordered_map(unordered_map&&);
      |                            ^~
p925.cpp:163:1: error: invalid constructor; you probably meant 'pmr::std::unordered_map (const pmr::std::unordered_map&)'
  163 | unordered_map(unordered_map&&);
      | ^~~~~~~~~~~~~
p925.cpp:164:30: error: 'Allocator' does not name a type; did you mean 'alloca'?
  164 | explicit unordered_map(const Allocator&);
      |                              ^~~~~~~~~
      |                              alloca
p925.cpp:165:43: error: 'type_identity_t' does not name a type
  165 | unordered_map(const unordered_map&, const type_identity_t<Allocator>&);
      |                                           ^~~~~~~~~~~~~~~
p925.cpp:165:58: error: expected ',' or '...' before '<' token
  165 | unordered_map(const unordered_map&, const type_identity_t<Allocator>&);
      |                                                          ^
p925.cpp:166:28: error: expected ',' or '...' before '&&' token
  166 | unordered_map(unordered_map&&, const type_identity_t<Allocator>&);
      |                            ^~
p925.cpp:166:1: error: invalid constructor; you probably meant 'pmr::std::unordered_map (const pmr::std::unordered_map&)'
  166 | unordered_map(unordered_map&&, const type_identity_t<Allocator>&);
      | ^~~~~~~~~~~~~
p925.cpp:167:31: error: expected ')' before '<' token
  167 | unordered_map(initializer_list<value_type> il,
      |              ~                ^
      |                               )
p925.cpp:172:24: error: expected ')' before 'n'
  172 | unordered_map(size_type n, const allocator_type& a)
      |              ~         ^~
      |                        )
p925.cpp:174:24: error: expected ')' before 'n'
  174 | unordered_map(size_type n, const hasher& hf, const allocator_type& a)
      |              ~         ^~
      |                        )
p925.cpp:177:51: error: 'size_type' has not been declared
  177 |   unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
      |                                                   ^~~~~~~~~
p925.cpp:177:70: error: 'allocator_type' does not name a type
  177 |   unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
      |                                                                      ^~~~~~~~~~~~~~
p925.cpp:180:51: error: 'size_type' has not been declared
  180 |   unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,
      |                                                   ^~~~~~~~~
p925.cpp:180:70: error: 'hasher' does not name a type; did you mean 'Hash'?
  180 |   unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,
      |                                                                      ^~~~~~
      |                                                                      Hash
p925.cpp:181:23: error: 'allocator_type' does not name a type
  181 |                 const allocator_type& a)
      |                       ^~~~~~~~~~~~~~
p925.cpp:182:59: error: 'container' has not been declared
  182 | : unordered_map(f, l, n, hf, key_equal(), a) { } template<container-compatible-range<value_type> R>
      |                                                           ^~~~~~~~~
p925.cpp:182:68: error: expected '>' before '-' token
  182 | : unordered_map(f, l, n, hf, key_equal(), a) { } template<container-compatible-range<value_type> R>
      |                                                                    ^
p925.cpp:183:29: error: expected ')' before ',' token
  183 |   unordered_map(from_range_t, R&& rg, size_type n, const allocator_type& a)
      |                ~            ^
      |                             )
p925.cpp:185:10: error: 'container' has not been declared
  185 | template<container-compatible-range<value_type> R>
      |          ^~~~~~~~~
p925.cpp:185:19: error: expected '>' before '-' token
  185 | template<container-compatible-range<value_type> R>
      |                   ^
p925.cpp:186:27: error: expected ')' before ',' token
  186 | unordered_map(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
      |              ~            ^
      |                           )
p925.cpp:188:31: error: expected ')' before '<' token
  188 | unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
      |              ~                ^
      |                               )
p925.cpp:190:31: error: expected ')' before '<' token
  190 | unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf,
      |              ~                ^
      |                               )
p925.cpp:194:87: error: expected ',' or '...' before '&&' token
  194 | unordered_map& operator=(const unordered_map&); unordered_map& operator=(unordered_map&&)
      |                                                                                       ^~
p925.cpp:194:89: error: expected ';' at end of member declaration
  194 | unordered_map& operator=(const unordered_map&); unordered_map& operator=(unordered_map&&)
      |                                                                                         ^
      |                                                                                          ;
p925.cpp:195:12: error: 'allocator_traits' has not been declared
  195 |   noexcept(allocator_traits<Allocator>::is_always_equal::value &&
      |            ^~~~~~~~~~~~~~~~
p925.cpp:195:28: error: expected ',' or '...' before '<' token
  195 |   noexcept(allocator_traits<Allocator>::is_always_equal::value &&
      |                            ^
p925.cpp:195:3: error: ISO C++ forbids declaration of 'noexcept' with no type [-fpermissive]
  195 |   noexcept(allocator_traits<Allocator>::is_always_equal::value &&
      |   ^~~~~~~~
p925.cpp:198:26: error: 'initializer_list' has not been declared
  198 | unordered_map& operator=(initializer_list<value_type>);
      |                          ^~~~~~~~~~~~~~~~
p925.cpp:198:42: error: expected ',' or '...' before '<' token
  198 | unordered_map& operator=(initializer_list<value_type>);
      |                                          ^
p925.cpp:199:1: error: 'allocator_type' does not name a type
  199 | allocator_type get_allocator() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:201:1: error: invalid use of template-name 'std::iterator' without an argument list
  201 | iterator       begin() noexcept;
      | ^~~~~~~~
p925.cpp:201:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
In file included from /usr/local/include/c++/12.1.0/string:45,
                 from /usr/local/include/c++/12.1.0/bits/locale_classes.h:40,
                 from /usr/local/include/c++/12.1.0/bits/ios_base.h:41,
                 from /usr/local/include/c++/12.1.0/ios:42,
                 from /usr/local/include/c++/12.1.0/ostream:38,
                 from /usr/local/include/c++/12.1.0/iostream:39,
                 from N4910.h:2:
/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
      |                                  ^~~~~~~~
p925.cpp:202:1: error: 'const_iterator' does not name a type
  202 | const_iterator begin() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:203:1: error: invalid use of template-name 'std::iterator' without an argument list
  203 | iterator       end() noexcept;
      | ^~~~~~~~
p925.cpp:203:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:204:1: error: 'const_iterator' does not name a type
  204 | const_iterator end() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:205:1: error: 'const_iterator' does not name a type
  205 | const_iterator cbegin() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:206:1: error: 'const_iterator' does not name a type
  206 | const_iterator cend() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:208:1: error: expected unqualified-id before '[' token
  208 | [[nodiscard]] bool empty() const noexcept;
      | ^
p925.cpp:209:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  209 | size_type size() const noexcept;
      | ^~~~~~~~~
      | size_t
p925.cpp:210:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  210 | size_type max_size() const noexcept;
      | ^~~~~~~~~
      | size_t
p925.cpp:212:15: warning: variadic templates only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  212 | template<class... Args> pair<iterator, bool> emplace(Args&&... args);
      |               ^~~
p925.cpp:212:44: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  212 | template<class... Args> pair<iterator, bool> emplace(Args&&... args);
      |                                            ^
p925.cpp:212:44: note:   expected a type, got 'iterator'
p925.cpp:212:58: error: expected ',' or '...' before '&&' token
  212 | template<class... Args> pair<iterator, bool> emplace(Args&&... args);
      |                                                          ^~
p925.cpp:212:68: error: parameter packs not expanded with '...':
  212 | template<class... Args> pair<iterator, bool> emplace(Args&&... args);
      |                                                                    ^
p925.cpp:212:68: note:         'Args'
p925.cpp:213:15: warning: variadic templates only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  213 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
      |               ^~~
p925.cpp:213:25: error: invalid use of template-name 'std::iterator' without an argument list
  213 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
      |                         ^~~~~~~~
p925.cpp:213:25: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
/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
      |                                  ^~~~~~~~
p925.cpp:213:108: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  213 | rgs> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
      |                                                                                         ^

p925.cpp:213:108: note:   expected a type, got 'iterator'
p925.cpp:213:123: error: 'value_type' does not name a type
  213 | mplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
      |                                                                                         ^~~~~~~~~~

p925.cpp:214:20: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  214 | pair<iterator, bool> insert(value_type&& obj);
      |                    ^
p925.cpp:214:20: note:   expected a type, got 'iterator'
p925.cpp:214:29: error: 'value_type' has not been declared
  214 | pair<iterator, bool> insert(value_type&& obj);
      |                             ^~~~~~~~~~
p925.cpp:214:39: error: expected ',' or '...' before '&&' token
  214 | pair<iterator, bool> insert(value_type&& obj);
      |                                       ^~
p925.cpp:215:38: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  215 | template<class P> pair<iterator, bool> insert(P&& obj);
      |                                      ^
p925.cpp:215:38: note:   expected a type, got 'iterator'
p925.cpp:215:48: error: expected ',' or '...' before '&&' token
  215 | template<class P> pair<iterator, bool> insert(P&& obj);
      |                                                ^~
p925.cpp:216:1: error: invalid use of template-name 'std::iterator' without an argument list
  216 | iterator insert(const_iterator hint, const value_type& obj);
      | ^~~~~~~~
p925.cpp:216:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:217:1: error: invalid use of template-name 'std::iterator' without an argument list
  217 | iterator insert(const_iterator hint, value_type&& obj);
      | ^~~~~~~~
p925.cpp:217:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:218:19: error: invalid use of template-name 'std::iterator' without an argument list
  218 | template<class P> iterator insert(const_iterator hint, P&& obj);
      |                   ^~~~~~~~
p925.cpp:218:19: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
/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
      |                                  ^~~~~~~~
p925.cpp:219:94: error: 'container' has not been declared
  219 | ate<class InputIterator> void insert(InputIterator first, InputIterator last); template<container-compatible-range<value_type> R>
      |                                                                                         ^~~~~~~~~

p925.cpp:219:103: error: expected '>' before '-' token
  219 |  InputIterator> void insert(InputIterator first, InputIterator last); template<container-compatible-range<value_type> R>
      |                                                                                         ^

p925.cpp:220:21: error: 'R' has not been declared
  220 |   void insert_range(R&& rg);
      |                     ^
p925.cpp:220:22: error: expected ',' or '...' before '&&' token
  220 |   void insert_range(R&& rg);
      |                      ^~
p925.cpp:221:13: error: 'initializer_list' has not been declared
  221 | void insert(initializer_list<value_type>);
      |             ^~~~~~~~~~~~~~~~
p925.cpp:221:29: error: expected ',' or '...' before '<' token
  221 | void insert(initializer_list<value_type>);
      |                             ^
p925.cpp:221:6: error: 'void pmr::std::unordered_map::insert(int)' cannot be overloaded with 'int pmr::std::unordered_map::insert(int)'
  221 | void insert(initializer_list<value_type>);
      |      ^~~~~~
p925.cpp:214:22: note: previous declaration 'int pmr::std::unordered_map::insert(int)'
  214 | pair<iterator, bool> insert(value_type&& obj);
      |                      ^~~~~~
p925.cpp:222:1: error: 'node_type' does not name a type
  222 | node_type extract(const_iterator position);
      | ^~~~~~~~~
p925.cpp:223:1: error: 'node_type' does not name a type
  223 | node_type extract(const key_type& x);
      | ^~~~~~~~~
p925.cpp:224:19: error: 'node_type' does not name a type
  224 | template<class K> node_type extract(K&& x);
      |                   ^~~~~~~~~
p925.cpp:225:1: error: 'insert_return_type' does not name a type
  225 | insert_return_type insert(node_type&& nh);
      | ^~~~~~~~~~~~~~~~~~
p925.cpp:226:1: error: invalid use of template-name 'std::iterator' without an argument list
  226 | iterator           insert(const_iterator hint, node_type&& nh);
      | ^~~~~~~~
p925.cpp:226:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:227:15: warning: variadic templates only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  227 | template<class... Args>
      |               ^~~
p925.cpp:228:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  228 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                      ^
p925.cpp:228:22: note:   expected a type, got 'iterator'
p925.cpp:228:42: error: 'key_type' does not name a type; did you mean 'key_t'?
  228 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                                          ^~~~~~~~
      |                                          key_t
p925.cpp:228:59: error: expected ',' or '...' before '&&' token
  228 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                                                           ^~
p925.cpp:228:69: error: parameter packs not expanded with '...':
  228 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                                                                     ^
p925.cpp:228:69: note:         'Args'
p925.cpp:229:15: warning: variadic templates only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  229 | template<class... Args>
      |               ^~~
p925.cpp:230:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  230 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                      ^
p925.cpp:230:22: note:   expected a type, got 'iterator'
p925.cpp:230:36: error: 'key_type' has not been declared
  230 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                                    ^~~~~~~~
p925.cpp:230:44: error: expected ',' or '...' before '&&' token
  230 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                                            ^~
p925.cpp:231:15: warning: variadic templates only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  231 | template<class... Args>
      |               ^~~
p925.cpp:232:3: error: invalid use of template-name 'std::iterator' without an argument list
  232 |   iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
      |   ^~~~~~~~
p925.cpp:232:3: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:233:15: warning: variadic templates only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  233 | template<class... Args>
      |               ^~~
p925.cpp:234:3: error: invalid use of template-name 'std::iterator' without an argument list
  234 |   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
      |   ^~~~~~~~
p925.cpp:234:3: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:236:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  236 |   pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
      |                      ^
p925.cpp:236:22: note:   expected a type, got 'iterator'
p925.cpp:236:47: error: 'key_type' does not name a type; did you mean 'key_t'?
  236 |   pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
      |                                               ^~~~~~~~
      |                                               key_t
p925.cpp:236:61: error: expected ',' or '...' before '&&' token
  236 |   pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
      |                                                             ^~
p925.cpp:238:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  238 |   pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
      |                      ^
p925.cpp:238:22: note:   expected a type, got 'iterator'
p925.cpp:238:41: error: 'key_type' has not been declared
  238 |   pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
      |                                         ^~~~~~~~
p925.cpp:238:49: error: expected ',' or '...' before '&&' token
  238 |   pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
      |                                                 ^~
p925.cpp:240:3: error: invalid use of template-name 'std::iterator' without an argument list
  240 |   iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
      |   ^~~~~~~~
p925.cpp:240:3: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:242:3: error: invalid use of template-name 'std::iterator' without an argument list
  242 |   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
      |   ^~~~~~~~
p925.cpp:242:3: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:243:1: error: invalid use of template-name 'std::iterator' without an argument list
  243 | iterator  erase(iterator position);
      | ^~~~~~~~
p925.cpp:243:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:244:1: error: invalid use of template-name 'std::iterator' without an argument list
  244 | iterator  erase(const_iterator position);
      | ^~~~~~~~
p925.cpp:244:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:245:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  245 | size_type erase(const key_type& k);
      | ^~~~~~~~~
      | size_t
p925.cpp:246:19: error: 'size_type' does not name a type; did you mean 'size_t'?
  246 | template<class K> size_type erase(K&& x);
      |                   ^~~~~~~~~
      |                   size_t
p925.cpp:247:1: error: invalid use of template-name 'std::iterator' without an argument list
  247 | iterator  erase(const_iterator first, const_iterator last);
      | ^~~~~~~~
p925.cpp:247:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:248:30: error: expected ';' at end of member declaration
  248 | void      swap(unordered_map&)
      |                              ^
      |                               ;
p925.cpp:249:12: error: 'allocator_traits' has not been declared
  249 |   noexcept(allocator_traits<Allocator>::is_always_equal::value &&
      |            ^~~~~~~~~~~~~~~~
p925.cpp:249:28: error: expected ',' or '...' before '<' token
  249 |   noexcept(allocator_traits<Allocator>::is_always_equal::value &&
      |                            ^
p925.cpp:249:3: error: ISO C++ forbids declaration of 'noexcept' with no type [-fpermissive]
  249 |   noexcept(allocator_traits<Allocator>::is_always_equal::value &&
      |   ^~~~~~~~
p925.cpp:249:3: error: 'int pmr::std::unordered_map::noexcept(int)' cannot be overloaded with 'int pmr::std::unordered_map::noexcept(int)'
p925.cpp:195:3: note: previous declaration 'int pmr::std::unordered_map::noexcept(int)'
  195 |   noexcept(allocator_traits<Allocator>::is_always_equal::value &&
      |   ^~~~~~~~
p925.cpp:252:17: error: expected ';' at end of member declaration
  252 | void      clear() noexcept;
      |                 ^
      |                  ;
p925.cpp:252:19: error: 'noexcept' does not name a type
  252 | void      clear() noexcept;
      |                   ^~~~~~~~
p925.cpp:252:19: note: C++11 'noexcept' only available with '-std=c++11' or '-std=gnu++11'
p925.cpp:254:14: error: 'pmr::std::unordered_map' is not a template
  254 |   void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
      |              ^~~~~~~~~~~~~
p925.cpp:254:28: error: 'Key' was not declared in this scope
  254 |   void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
      |                            ^~~
p925.cpp:254:44: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  254 |   void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
      |                                            ^~~~~~~~~
      |                                            alloca
p925.cpp:256:14: error: 'pmr::std::unordered_map' is not a template
  256 |   void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
      |              ^~~~~~~~~~~~~
p925.cpp:256:28: error: 'Key' was not declared in this scope
  256 |   void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
      |                            ^~~
p925.cpp:256:44: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  256 |   void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
      |                                            ^~~~~~~~~
      |                                            alloca
p925.cpp:256:54: error: expected ',' or '...' before '&&' token
  256 |   void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
      |                                                      ^~
p925.cpp:258:14: error: 'unordered_multimap' has not been declared
  258 |   void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);
      |              ^~~~~~~~~~~~~~~~~~
p925.cpp:258:32: error: expected ',' or '...' before '<' token
  258 |   void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);
      |                                ^
p925.cpp:260:14: error: 'unordered_multimap' has not been declared
  260 |   void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);
      |              ^~~~~~~~~~~~~~~~~~
p925.cpp:260:32: error: expected ',' or '...' before '<' token
  260 |   void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);
      |                                ^
p925.cpp:260:8: error: 'template<class H2, class P2> void pmr::std::unordered_map::merge(int)' cannot be overloaded with 'template<class H2, class P2> void pmr::std::unordered_map::merge(int)'
  260 |   void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);
      |        ^~~~~
p925.cpp:258:8: note: previous declaration 'template<class H2, class P2> void pmr::std::unordered_map::merge(int)'
  258 |   void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);
      |        ^~~~~
p925.cpp:262:1: error: 'hasher' does not name a type; did you mean 'Hash'?
  262 | hasher hash_function() const;
      | ^~~~~~
      | Hash
p925.cpp:263:1: error: 'key_equal' does not name a type
  263 | key_equal key_eq() const;
      | ^~~~~~~~~
p925.cpp:265:1: error: invalid use of template-name 'std::iterator' without an argument list
  265 | iterator
      | ^~~~~~~~
p925.cpp:265:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:271:12: error: 'key_type' does not name a type; did you mean 'key_t'?
  271 | find(const key_type& k) const;
      |            ^~~~~~~~
      |            key_t
p925.cpp:271:1: error: ISO C++ forbids declaration of 'find' with no type [-fpermissive]
  271 | find(const key_type& k) const;
      | ^~~~
p925.cpp:272:12: error: 'K' does not name a type
  272 | find(const K& k);
      |            ^
p925.cpp:272:1: error: ISO C++ forbids declaration of 'find' with no type [-fpermissive]
  272 | find(const K& k);
      | ^~~~
p925.cpp:273:3: error: 'const_iterator' does not name a type
  273 |   const_iterator find(const K& k) const;
      |   ^~~~~~~~~~~~~~
p925.cpp:275:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  275 | size_type        count(const key_type& k) const;
      | ^~~~~~~~~
      | size_t
p925.cpp:277:3: error: 'size_type' does not name a type; did you mean 'size_t'?
  277 |   size_type      count(const K& k) const;
      |   ^~~~~~~~~
      |   size_t
p925.cpp:278:33: error: 'key_type' does not name a type; did you mean 'key_t'?
  278 | bool             contains(const key_type& k) const;
      |                                 ^~~~~~~~
      |                                 key_t
p925.cpp:281:30: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  281 |       pair<iterator, iterator>
      |                              ^
p925.cpp:281:30: note:   expected a type, got 'iterator'
p925.cpp:281:30: error: type/value mismatch at argument 2 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
p925.cpp:281:30: note:   expected a type, got 'iterator'
p925.cpp:282:12: error: 'const_iterator' was not declared in this scope
  282 |       pair<const_iterator, const_iterator>
      |            ^~~~~~~~~~~~~~
p925.cpp:282:28: error: 'const_iterator' was not declared in this scope
  282 |       pair<const_iterator, const_iterator>
      |                            ^~~~~~~~~~~~~~
p925.cpp:282:42: error: template argument 1 is invalid
  282 |       pair<const_iterator, const_iterator>
      |                                          ^
p925.cpp:282:42: error: template argument 2 is invalid
p925.cpp:285:45: error: 'mapped_type' does not name a type
  285 | mapped_type& operator[](const key_type& k); mapped_type& operator[](key_type&& k); mapped_type& at(const key_type& k);
      |                                             ^~~~~~~~~~~
p925.cpp:285:84: error: 'mapped_type' does not name a type
  285 | mapped_type& operator[](const key_type& k); mapped_type& operator[](key_type&& k); mapped_type& at(const key_type& k);
      |                                                                                    ^~~~~~~~~~~
p925.cpp:286:7: error: 'mapped_type' does not name a type
  286 | const mapped_type& at(const key_type& k) const;
      |       ^~~~~~~~~~~
p925.cpp:288:7: error: 'size_type' does not name a type; did you mean 'size_t'?
  288 |       size_type bucket_count() const noexcept;
      |       ^~~~~~~~~
      |       size_t
p925.cpp:289:7: error: 'size_type' does not name a type; did you mean 'size_t'?
  289 |       size_type max_bucket_count() const noexcept;
      |       ^~~~~~~~~
      |       size_t
p925.cpp:290:7: error: 'size_type' does not name a type; did you mean 'size_t'?
  290 |       size_type bucket_size(size_type n) const;
      |       ^~~~~~~~~
      |       size_t
p925.cpp:291:7: error: 'size_type' does not name a type; did you mean 'size_t'?
  291 |       size_type bucket(const key_type& k) const;
      |       ^~~~~~~~~
      |       size_t
p925.cpp:292:7: error: 'local_iterator' does not name a type
  292 |       local_iterator begin(size_type n);
      |       ^~~~~~~~~~~~~~
p925.cpp:293:7: error: 'const_local_iterator' does not name a type
  293 |       const_local_iterator begin(size_type n) const;
      |       ^~~~~~~~~~~~~~~~~~~~
p925.cpp:294:7: error: 'local_iterator' does not name a type
  294 |       local_iterator end(size_type n);
      |       ^~~~~~~~~~~~~~
p925.cpp:295:7: error: 'const_local_iterator' does not name a type
  295 |       const_local_iterator end(size_type n) const;
      |       ^~~~~~~~~~~~~~~~~~~~
p925.cpp:296:7: error: 'const_local_iterator' does not name a type
  296 |       const_local_iterator cbegin(size_type n) const;
      |       ^~~~~~~~~~~~~~~~~~~~
p925.cpp:297:7: error: 'const_local_iterator' does not name a type
  297 |       const_local_iterator cend(size_type n) const;
      |       ^~~~~~~~~~~~~~~~~~~~
p925.cpp:299:27: error: expected ';' at end of member declaration
  299 |       float load_factor() const noexcept;
      |                           ^~~~~
      |                                ;
p925.cpp:299:33: error: 'noexcept' does not name a type
  299 |       float load_factor() const noexcept;
      |                                 ^~~~~~~~
p925.cpp:299:33: note: C++11 'noexcept' only available with '-std=c++11' or '-std=gnu++11'
p925.cpp:300:31: error: expected ';' at end of member declaration
  300 |       float max_load_factor() const noexcept;
      |                               ^~~~~
      |                                    ;
p925.cpp:300:37: error: 'noexcept' does not name a type
  300 |       float max_load_factor() const noexcept;
      |                                     ^~~~~~~~
p925.cpp:300:37: note: C++11 'noexcept' only available with '-std=c++11' or '-std=gnu++11'
p925.cpp:302:19: error: 'size_type' has not been declared
  302 |       void rehash(size_type n);
      |                   ^~~~~~~~~
p925.cpp:303:20: error: 'size_type' has not been declared
  303 |       void reserve(size_type n);
      |                    ^~~~~~~~~
p925.cpp:155:63: error: 'see' was not declared in this scope
  155 | unordered_map(InputIterator f, InputIterator l, size_type n = see below,
      |                                                               ^~~
p925.cpp:156:36: error: there are no arguments to 'hasher' that depend on a template parameter, so a declaration of 'hasher' must be available [-fpermissive]
  156 |                 const hasher& hf = hasher(),
      |                                    ^~~~~~
p925.cpp:156:36: note: (if you use '-fpermissive', G++ will accept your code, but allowing the use of an undeclared name is deprecated)
p925.cpp:157:40: error: there are no arguments to 'key_equal' that depend on a template parameter, so a declaration of 'key_equal' must be available [-fpermissive]
  157 |                 const key_equal& eql = key_equal(),
      |                                        ^~~~~~~~~
p925.cpp:158:43: error: there are no arguments to 'allocator_type' that depend on a template parameter, so a declaration of 'allocator_type' must be available [-fpermissive]
  158 |                 const allocator_type& a = allocator_type());
      |                                           ^~~~~~~~~~~~~~
p925.cpp: In constructor 'pmr::std::unordered_map::unordered_map(InputIterator, InputIterator, int, const int&)':
p925.cpp:178:30: error: there are no arguments to 'hasher' that depend on a template parameter, so a declaration of 'hasher' must be available [-fpermissive]
  178 |     : unordered_map(f, l, n, hasher(), key_equal(), a) { }
      |                              ^~~~~~
p925.cpp:178:40: error: there are no arguments to 'key_equal' that depend on a template parameter, so a declaration of 'key_equal' must be available [-fpermissive]
  178 |     : unordered_map(f, l, n, hasher(), key_equal(), a) { }
      |                                        ^~~~~~~~~
p925.cpp:178:54: warning: delegating constructors only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  178 |     : unordered_map(f, l, n, hasher(), key_equal(), a) { }
      |                                                      ^
p925.cpp: In constructor 'pmr::std::unordered_map::unordered_map(InputIterator, InputIterator, int, const int&, const int&)':
p925.cpp:182:30: error: there are no arguments to 'key_equal' that depend on a template parameter, so a declaration of 'key_equal' must be available [-fpermissive]
  182 | : unordered_map(f, l, n, hf, key_equal(), a) { } template<container-compatible-range<value_type> R>
      |                              ^~~~~~~~~
p925.cpp:182:44: warning: delegating constructors only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  182 | : unordered_map(f, l, n, hf, key_equal(), a) { } template<container-compatible-range<value_type> R>
      |                                            ^
p925.cpp: At global scope:
p925.cpp:306:14: error: 'hash' does not name a type; did you mean 'Hash'?
  306 | class Hash = hash<iter_key_type<InputIterator>>,
      |              ^~~~
      |              Hash
p925.cpp:306:18: error: expected '>' before '<' token
  306 | class Hash = hash<iter_key_type<InputIterator>>,
      |                  ^
p925.cpp:310:103: error: expected unqualified-id before ';' token
  310 | nordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash, Pred, Allocator>;
      |                                                                                                   ^

p925.cpp:311:10: error: 'ranges' has not been declared
  311 | template<ranges::input_range R, class Hash = hash<range_key_type<R>>, class Pred = equal_to<range-key-type<R>>,
      |          ^~~~~~
p925.cpp:311:30: error: expected '>' before 'R'
  311 | template<ranges::input_range R, class Hash = hash<range_key_type<R>>, class Pred = equal_to<range-key-type<R>>,
      |                              ^
p925.cpp:314:81: error: expected unqualified-id before ';' token
  314 | -> unordered_map<range_key_type<R>, range-mapped-type<R>, Hash, Pred, Allocator>;
      |                                                                                 ^
p925.cpp:315:56: error: 'key_type' does not name a type; did you mean 'key_t'?
  315 |                                      equal_range(const key_type& k);
      |                                                        ^~~~~~~~
      |                                                        key_t
p925.cpp:315:68: error: expected constructor, destructor, or type conversion before ';' token
  315 |                                      equal_range(const key_type& k);
      |                                                                    ^
p925.cpp:316:56: error: 'key_type' does not name a type; did you mean 'key_t'?
  316 |                                      equal_range(const key_type& k) const;
      |                                                        ^~~~~~~~
      |                                                        key_t
p925.cpp:316:74: error: expected constructor, destructor, or type conversion before ';' token
  316 |                                      equal_range(const key_type& k) const;
      |                                                                          ^
p925.cpp:317:56: error: 'K' does not name a type
  317 |                                      equal_range(const K& k);
      |                                                        ^
p925.cpp:317:61: error: expected constructor, destructor, or type conversion before ';' token
  317 |                                      equal_range(const K& k);
      |                                                             ^
p925.cpp:318:6: error: 'const_iterator' was not declared in this scope
  318 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |      ^~~~~~~~~~~~~~
p925.cpp:318:22: error: 'const_iterator' was not declared in this scope
  318 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                      ^~~~~~~~~~~~~~
p925.cpp:318:36: error: template argument 1 is invalid
  318 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                    ^
p925.cpp:318:36: error: template argument 2 is invalid
p925.cpp:318:56: error: 'K' does not name a type
  318 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                                        ^
p925.cpp:318:62: error: non-member function 'int pmr::std::equal_range(const int&)' cannot have cv-qualifier
  318 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                                              ^~~~~
p925.cpp:319:26: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  319 |   pair<iterator, iterator>
      |                          ^
p925.cpp:319:26: note:   expected a type, got 'iterator'
p925.cpp:319:26: error: type/value mismatch at argument 2 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
p925.cpp:319:26: note:   expected a type, got 'iterator'
p925.cpp:320:1: error: expected unqualified-id before 'template'
  320 | template<class K>
      | ^~~~~~~~
p925.cpp:327:28: error: expected ')' before ',' token
  327 | unordered_map(InputIterator, InputIterator, typename see_below::size_type, Allocator)
      |              ~             ^
      |                            )
p925.cpp:331:37: error: expected ')' before ',' token
  331 |          unordered_map(InputIterator, InputIterator, Allocator)
      |                       ~             ^
      |                                     )
p925.cpp:335:28: error: expected ')' before ',' token
  335 | unordered_map(InputIterator, InputIterator, typename see_below::size_type, Hash, Allocator)
      |              ~             ^
      |                            )
p925.cpp:337:10: error: 'ranges' has not been declared
  337 | template<ranges::\tcode{input_range} R, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Allocator)
      |          ^~~~~~
p925.cpp:337:24: error: expected '>' before '{' token
  337 | template<ranges::\tcode{input_range} R, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Allocator)
      |                        ^
p925.cpp:337:24: error: expected unqualified-id before '{' token
p925.cpp:337:38: error: 'R' does not name a type
  337 | template<ranges::\tcode{input_range} R, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Allocator)
      |                                      ^
p925.cpp:339:17: error: 'ranges' has not been declared
  339 |        template<ranges::input_range R, class Allocator>
      |                 ^~~~~~
p925.cpp:339:37: error: expected '>' before 'R'
  339 |        template<ranges::input_range R, class Allocator>
      |                                     ^
p925.cpp:340:36: error: expected ')' before ',' token
  340 |          unordered_map(from_range_t, R&&, Allocator)
      |                       ~            ^
      |                                    )
p925.cpp:342:10: error: 'ranges' has not been declared
  342 | template<ranges::input_range R, class Hash, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
      |          ^~~~~~
p925.cpp:342:30: error: expected '>' before 'R'
  342 | template<ranges::input_range R, class Hash, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
      |                              ^
p925.cpp:342:88: error: expected ')' before ',' token
  342 | template<ranges::input_range R, class Hash, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
      |                                                                           ~            ^
      |                                                                                        )
p925.cpp:344:77: error: expected ')' before '<' token
  344 | template<class Key, class T, class Allocator> unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type,
      |                                                            ~                ^
      |                                                                             )
p925.cpp:348:40: error: expected ')' before '<' token
  348 |          unordered_map(initializer_list<pair<Key, T>>, Allocator)
      |                       ~                ^
      |                                        )
p925.cpp:350:89: error: expected ')' before '<' token
  350 | template<class Key, class T, class Hash, class Allocator> unordered_map(initializer_list<pair<Key, T>>, typename see_below::size_type, Hash, Allocator)
      |                                                                        ~                ^
      |                                                                                         )
p925.cpp:355:1: error: ISO C++ forbids declaration of 'unordered_map' with no type [-fpermissive]
  355 | unordered_map() : unordered_map(size_type(see below)) { } explicit unordered_map(size_type n,
      | ^~~~~~~~~~~~~
p925.cpp: In function 'int pmr::unordered_map()':
p925.cpp:355:19: error: only constructors take member initializers
  355 | unordered_map() : unordered_map(size_type(see below)) { } explicit unordered_map(size_type n,
      |                   ^~~~~~~~~~~~~
p925.cpp:355:43: error: 'see' was not declared in this scope
  355 | unordered_map() : unordered_map(size_type(see below)) { } explicit unordered_map(size_type n,
      |                                           ^~~
p925.cpp:355:33: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  355 | unordered_map() : unordered_map(size_type(see below)) { } explicit unordered_map(size_type n,
      |                                 ^~~~~~~~~
      |                                 size_t
p925.cpp:355:57: warning: no return statement in function returning non-void [-Wreturn-type]
  355 | unordered_map() : unordered_map(size_type(see below)) { } explicit unordered_map(size_type n,
      |                                                         ^
p925.cpp: At global scope:
p925.cpp:355:68: error: ISO C++ forbids declaration of 'unordered_map' with no type [-fpermissive]
  355 | unordered_map() : unordered_map(size_type(see below)) { } explicit unordered_map(size_type n,
      |                                                                    ^~~~~~~~~~~~~
p925.cpp:355:59: error: 'explicit' outside class declaration
  355 | unordered_map() : unordered_map(size_type(see below)) { } explicit unordered_map(size_type n,
      |                                                           ^~~~~~~~
p925.cpp:355:82: error: 'int pmr::unordered_map' redeclared as different kind of entity
  355 | unordered_map() : unordered_map(size_type(see below)) { } explicit unordered_map(size_type n,
      |                                                                                  ^~~~~~~~~
p925.cpp:355:1: note: previous declaration 'int pmr::unordered_map()'
  355 | unordered_map() : unordered_map(size_type(see below)) { } explicit unordered_map(size_type n,
      | ^~~~~~~~~~~~~
p925.cpp:355:82: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  355 | unordered_map() : unordered_map(size_type(see below)) { } explicit unordered_map(size_type n,
      |                                                                                  ^~~~~~~~~
      |                                                                                  size_t
p925.cpp:356:27: error: expected primary-expression before 'const'
  356 |                           const hasher& hf = hasher(),
      |                           ^~~~~
p925.cpp:357:27: error: expected primary-expression before 'const'
  357 |                           const key_equal& eql = key_equal(),
      |                           ^~~~~
p925.cpp:358:19: error: expected primary-expression before 'const'
  358 |                   const allocator_type& a = allocator_type());
      |                   ^~~~~
p925.cpp:361:16: error: 'hasher' does not name a type
  361 |          const hasher& hf = hasher(),
      |                ^~~~~~
p925.cpp:368:1: error: 'size_type' has not been declared
  368 | size_type n = see_below,
      | ^~~~~~~~~
p925.cpp:368:15: error: 'see_below' was not declared in this scope
  368 | size_type n = see_below,
      |               ^~~~~~~~~
p925.cpp:369:7: error: 'hasher' does not name a type
  369 | const hasher& hf = hasher(),
      |       ^~~~~~
p925.cpp:369:20: error: there are no arguments to 'hasher' that depend on a template parameter, so a declaration of 'hasher' must be available [-fpermissive]
  369 | const hasher& hf = hasher(),
      |                    ^~~~~~
p925.cpp:370:7: error: 'key_equal' does not name a type
  370 | const key_equal& eql = key_equal(),
      |       ^~~~~~~~~
p925.cpp:370:24: error: there are no arguments to 'key_equal' that depend on a template parameter, so a declaration of 'key_equal' must be available [-fpermissive]
  370 | const key_equal& eql = key_equal(),
      |                        ^~~~~~~~~
p925.cpp:371:7: error: 'allocator_type' does not name a type
  371 | const allocator_type& a = allocator_type());
      |       ^~~~~~~~~~~~~~
p925.cpp:371:27: error: there are no arguments to 'allocator_type' that depend on a template parameter, so a declaration of 'allocator_type' must be available [-fpermissive]
  371 | const allocator_type& a = allocator_type());
      |                           ^~~~~~~~~~~~~~
p925.cpp:371:44: error: expected constructor, destructor, or type conversion before ';' token
  371 | const allocator_type& a = allocator_type());
      |                                            ^
p925.cpp:372:10: error: 'container' has not been declared
  372 | template<container-compatible-range<value_type> R> unordered_map(from_range_t, R&& rg,
      |          ^~~~~~~~~
p925.cpp:372:19: error: expected '>' before '-' token
  372 | template<container-compatible-range<value_type> R> unordered_map(from_range_t, R&& rg,
      |                   ^
p925.cpp:372:65: error: expected constructor, destructor, or type conversion before '(' token
  372 | template<container-compatible-range<value_type> R> unordered_map(from_range_t, R&& rg,
      |                                                                 ^
p925.cpp:377:14: error: expected constructor, destructor, or type conversion before '(' token
  377 | unordered_map(initializer_list<value_type> il, size_type n = see below,
      |              ^
p925.cpp:382:7: error: 'mapped_type' does not name a type
  382 | const mapped_type& at(const key_type& k) const;
      |       ^~~~~~~~~~~
p925.cpp:386:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  386 |   pair<iterator, bool> insert(P&& obj);
      |                      ^
p925.cpp:386:22: note:   expected a type, got 'iterator'
p925.cpp:386:32: error: expected ',' or '...' before '&&' token
  386 |   pair<iterator, bool> insert(P&& obj);
      |                                ^~
p925.cpp:389:3: error: invalid use of template-name 'std::iterator' without an argument list
  389 |   iterator insert(const_iterator hint, P&& obj);
      |   ^~~~~~~~
p925.cpp:389:3: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:392:15: warning: variadic templates only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  392 | template<class... Args>
      |               ^~~
p925.cpp:393:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  393 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                      ^
p925.cpp:393:22: note:   expected a type, got 'iterator'
p925.cpp:393:42: error: 'key_type' does not name a type; did you mean 'key_t'?
  393 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                                          ^~~~~~~~
      |                                          key_t
p925.cpp:393:59: error: expected ',' or '...' before '&&' token
  393 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                                                           ^~
p925.cpp:393:69: error: parameter packs not expanded with '...':
  393 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                                                                     ^
p925.cpp:393:69: note:         'Args'
p925.cpp:394:18: warning: variadic templates only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  394 |    template<class... Args>
      |                  ^~~
p925.cpp:395:6: error: invalid use of template-name 'std::iterator' without an argument list
  395 |      iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
      |      ^~~~~~~~
p925.cpp:395:6: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:400:15: warning: variadic templates only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  400 | template<class... Args>
      |               ^~~
p925.cpp:401:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  401 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                      ^
p925.cpp:401:22: note:   expected a type, got 'iterator'
p925.cpp:401:36: error: 'template<class ... Args> int pmr::try_emplace' conflicts with a previous declaration
  401 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                                    ^~~~~~~~
p925.cpp:393:24: note: previous declaration 'int pmr::try_emplace(const int&, <type error>)'
  393 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                        ^~~~~~~~~~~
p925.cpp:401:36: error: 'key_type' was not declared in this scope; did you mean 'key_t'?
  401 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                                    ^~~~~~~~
      |                                    key_t
p925.cpp:401:47: error: 'k' was not declared in this scope
  401 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                                               ^
p925.cpp:401:54: error: expected primary-expression before '&&' token
  401 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                                                      ^~
p925.cpp:401:64: error: expression list treated as compound expression in initializer [-fpermissive]
  401 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                                                                ^
p925.cpp:401:24: warning: variable templates only available with '-std=c++14' or '-std=gnu++14' [-Wc++14-extensions]
  401 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                        ^~~~~~~~~~~
p925.cpp:402:15: warning: variadic templates only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
  402 | template<class... Args>
      |               ^~~
p925.cpp:403:3: error: invalid use of template-name 'std::iterator' without an argument list
  403 |   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
      |   ^~~~~~~~
p925.cpp:403:3: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:409:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  409 |   pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
      |                      ^
p925.cpp:409:22: note:   expected a type, got 'iterator'
p925.cpp:409:47: error: 'key_type' does not name a type; did you mean 'key_t'?
  409 |   pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
      |                                               ^~~~~~~~
      |                                               key_t
p925.cpp:409:61: error: expected ',' or '...' before '&&' token
  409 |   pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
      |                                                             ^~
p925.cpp:411:3: error: invalid use of template-name 'std::iterator' without an argument list
  411 |   iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
      |   ^~~~~~~~
p925.cpp:411:3: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:414:1: error: 'ward' does not name a type
  414 | ward<M>(obj).
      | ^~~~
p925.cpp:421:3: error: invalid use of template-name 'std::iterator' without an argument list
  421 |   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
      |   ^~~~~~~~
p925.cpp:421:3: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:424:6: error: 'forward' in namespace 'pmr::std' does not name a template type
  424 | std::forward<M>(obj).
      |      ^~~~~~~
p925.cpp:433:8: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
  433 |        auto original_size = c.size();
      |        ^~~~
      |        ----
p925.cpp:433:13: error: 'original_size' does not name a type
  433 |        auto original_size = c.size();
      |             ^~~~~~~~~~~~~
p925.cpp:434:8: error: expected unqualified-id before 'for'
  434 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |        ^~~
p925.cpp:434:49: error: 'i' does not name a type
  434 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                                 ^
p925.cpp:434:60: error: expected unqualified-id before ')' token
  434 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                                            ^
p925.cpp:439:8: error: expected unqualified-id before 'return'
  439 |        return original_size - c.size();
      |        ^~~~~~
p925.cpp:448:30: error: 'hash' does not name a type; did you mean 'Hash'?
  448 |                 class Hash = hash<Key>,
      |                              ^~~~
      |                              Hash
p925.cpp:448:34: error: expected '>' before '<' token
  448 |                 class Hash = hash<Key>,
      |                                  ^
p925.cpp:451:26: error: expected unqualified-id before '{' token
  451 | class unordered_multimap {
      |                          ^
p925.cpp:620:14: error: 'hash' does not name a type; did you mean 'Hash'?
  620 | class Hash = hash<iter_key_type<InputIterator>>,
      |              ^~~~
      |              Hash
p925.cpp:620:18: error: expected '>' before '<' token
  620 | class Hash = hash<iter_key_type<InputIterator>>,
      |                  ^
p925.cpp:627:49: error: expected unqualified-id before ';' token
  627 |                           Hash, Pred, Allocator>;
      |                                                 ^
p925.cpp:628:10: error: 'ranges' has not been declared
  628 | template<ranges::input_range R,
      |          ^~~~~~
p925.cpp:628:30: error: expected '>' before 'R'
  628 | template<ranges::input_range R,
      |                              ^
p925.cpp:633:86: error: expected unqualified-id before ';' token
  633 | -> unordered_multimap<range_key_type<R>, range_mapped_type<R>, Hash, Pred, Allocator>;
      |                                                                                      ^
p925.cpp:634:43: error: 'hash' does not name a type; did you mean 'Hash'?
  634 | template<class Key, class T, class Hash = hash<Key>,
      |                                           ^~~~
      |                                           Hash
p925.cpp:634:47: error: expected '>' before '<' token
  634 | template<class Key, class T, class Hash = hash<Key>,
      |                                               ^
p925.cpp:639:57: error: expected unqualified-id before ';' token
  639 |     -> unordered_multimap<Key, T, Hash, Pred, Allocator>;
      |                                                         ^
p925.cpp:641:59: error: expected nested-name-specifier before 'see'
  641 | unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Allocator)
      |                                                           ^~~
p925.cpp:641:63: error: expected ',' or '...' before 'below'
  641 | unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Allocator)
      |                                                               ^~~~~
p925.cpp:642:4: error: 'unordered_multimap' does not name a type; did you mean 'unordered_map'?
  642 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |    ^~~~~~~~~~~~~~~~~~
      |    unordered_map
p925.cpp:642:22: error: expected constructor, destructor, or type conversion before '<' token
  642 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                      ^
p925.cpp:646:4: error: 'unordered_multimap' does not name a type; did you mean 'unordered_map'?
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |    ^~~~~~~~~~~~~~~~~~
      |    unordered_map
p925.cpp:646:22: error: expected constructor, destructor, or type conversion before '<' token
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                      ^
p925.cpp:649:118: error: expected nested-name-specifier before 'see'
  649 |  class Hash, class Allocator> unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Hash,
      |                                                                                         ^~~

p925.cpp:649:122: error: expected ',' or '...' before 'below'
  649 | ss Hash, class Allocator> unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Hash,
      |                                                                                         ^~~~~

p925.cpp:651:4: error: 'unordered_multimap' does not name a type; did you mean 'unordered_map'?
  651 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash,
      |    ^~~~~~~~~~~~~~~~~~
      |    unordered_map
p925.cpp:651:22: error: expected constructor, destructor, or type conversion before '<' token
  651 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash,
      |                      ^
p925.cpp:653:10: error: 'ranges' has not been declared
  653 | template<ranges::input_range R, class Allocator>
      |          ^~~~~~
p925.cpp:653:30: error: expected '>' before 'R'
  653 | template<ranges::input_range R, class Allocator>
      |                              ^
p925.cpp:654:19: error: expected constructor, destructor, or type conversion before '(' token
  654 | unordered_multimap(from_range_t, R&&, typename see_below::size_type, Allocator)
      |                   ^
p925.cpp:656:17: error: 'ranges' has not been declared
  656 |        template<ranges::input_range R, class Allocator>
      |                 ^~~~~~
p925.cpp:656:37: error: expected '>' before 'R'
  656 |        template<ranges::input_range R, class Allocator>
      |                                     ^
p925.cpp:657:28: error: expected constructor, destructor, or type conversion before '(' token
  657 |          unordered_multimap(from_range_t, R&&, Allocator)
      |                            ^
p925.cpp:659:10: error: 'ranges' has not been declared
  659 | template<ranges::input_range R, class Hash, class Allocator> unordered_multimap(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
      |          ^~~~~~
p925.cpp:659:30: error: expected '>' before 'R'
  659 | template<ranges::input_range R, class Hash, class Allocator> unordered_multimap(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
      |                              ^
p925.cpp:659:80: error: expected constructor, destructor, or type conversion before '(' token
  659 | template<ranges::input_range R, class Hash, class Allocator> unordered_multimap(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
      |                                                                                ^
p925.cpp:661:65: error: expected constructor, destructor, or type conversion before '(' token
  661 | template<class Key, class T, class Allocator> unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type,
      |                                                                 ^
p925.cpp:665:28: error: expected constructor, destructor, or type conversion before '(' token
  665 |          unordered_multimap(initializer_list<pair<Key, T>>, Allocator)
      |                            ^
p925.cpp:667:77: error: expected constructor, destructor, or type conversion before '(' token
  667 | template<class Key, class T, class Hash, class Allocator> unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type,
      |                                                                             ^
p925.cpp:673:1: error: ISO C++ forbids declaration of 'unordered_multimap' with no type [-fpermissive]
  673 | unordered_multimap() : unordered_multimap(size_type(see below)) { } explicit unordered_multimap(size_type n,
      | ^~~~~~~~~~~~~~~~~~
p925.cpp: In function 'int pmr::unordered_multimap()':
p925.cpp:673:24: error: only constructors take member initializers
  673 | unordered_multimap() : unordered_multimap(size_type(see below)) { } explicit unordered_multimap(size_type n,
      |                        ^~~~~~~~~~~~~~~~~~
p925.cpp:673:53: error: 'see' was not declared in this scope
  673 | unordered_multimap() : unordered_multimap(size_type(see below)) { } explicit unordered_multimap(size_type n,
      |                                                     ^~~
p925.cpp:673:43: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  673 | unordered_multimap() : unordered_multimap(size_type(see below)) { } explicit unordered_multimap(size_type n,
      |                                           ^~~~~~~~~
      |                                           size_t
p925.cpp:673:67: warning: no return statement in function returning non-void [-Wreturn-type]
  673 | unordered_multimap() : unordered_multimap(size_type(see below)) { } explicit unordered_multimap(size_type n,
      |                                                                   ^
p925.cpp: At global scope:
p925.cpp:673:78: error: ISO C++ forbids declaration of 'unordered_multimap' with no type [-fpermissive]
  673 | unordered_multimap() : unordered_multimap(size_type(see below)) { } explicit unordered_multimap(size_type n,
      |                                                                              ^~~~~~~~~~~~~~~~~~
p925.cpp:673:69: error: 'explicit' outside class declaration
  673 | unordered_multimap() : unordered_multimap(size_type(see below)) { } explicit unordered_multimap(size_type n,
      |                                                                     ^~~~~~~~
p925.cpp:673:97: error: 'int pmr::unordered_multimap' redeclared as different kind of entity
  673 | d_multimap() : unordered_multimap(size_type(see below)) { } explicit unordered_multimap(size_type n,
      |                                                                                         ^~~~~~~~~

p925.cpp:673:1: note: previous declaration 'int pmr::unordered_multimap()'
  673 | unordered_multimap() : unordered_multimap(size_type(see below)) { } explicit unordered_multimap(size_type n,
      | ^~~~~~~~~~~~~~~~~~
p925.cpp:673:97: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  673 | d_multimap() : unordered_multimap(size_type(see below)) { } explicit unordered_multimap(size_type n,
      |                                                                                         ^~~~~~~~~
      |                                                                                         size_t
p925.cpp:674:1: error: expected primary-expression before 'const'
  674 | const hasher& hf = hasher(),
      | ^~~~~
p925.cpp:675:1: error: expected primary-expression before 'const'
  675 | const key_equal& eql = key_equal(),
      | ^~~~~
p925.cpp:676:1: error: expected primary-expression before 'const'
  676 | const allocator_type& a = allocator_type());
      | ^~~~~
p925.cpp:679:1: error: 'size_type' has not been declared
  679 | size_type n = see_below,
      | ^~~~~~~~~
p925.cpp:679:15: error: 'see_below' was not declared in this scope
  679 | size_type n = see_below,
      |               ^~~~~~~~~
p925.cpp:680:7: error: 'hasher' does not name a type
  680 | const hasher& hf = hasher(),
      |       ^~~~~~
p925.cpp:680:20: error: there are no arguments to 'hasher' that depend on a template parameter, so a declaration of 'hasher' must be available [-fpermissive]
  680 | const hasher& hf = hasher(),
      |                    ^~~~~~
p925.cpp:681:7: error: 'key_equal' does not name a type
  681 | const key_equal& eql = key_equal(),
      |       ^~~~~~~~~
p925.cpp:681:24: error: there are no arguments to 'key_equal' that depend on a template parameter, so a declaration of 'key_equal' must be available [-fpermissive]
  681 | const key_equal& eql = key_equal(),
      |                        ^~~~~~~~~
p925.cpp:682:7: error: 'allocator_type' does not name a type
  682 | const allocator_type& a = allocator_type());
      |       ^~~~~~~~~~~~~~
p925.cpp:682:27: error: there are no arguments to 'allocator_type' that depend on a template parameter, so a declaration of 'allocator_type' must be available [-fpermissive]
  682 | const allocator_type& a = allocator_type());
      |                           ^~~~~~~~~~~~~~
p925.cpp:682:44: error: expected constructor, destructor, or type conversion before ';' token
  682 | const allocator_type& a = allocator_type());
      |                                            ^
p925.cpp:683:10: error: 'container_compatible_range' has not been declared
  683 | template<container_compatible_range<value_type> R> unordered_multimap(from_range_t, R&& rg,
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp:683:36: error: expected '>' before '<' token
  683 | template<container_compatible_range<value_type> R> unordered_multimap(from_range_t, R&& rg,
      |                                    ^
p925.cpp:683:70: error: expected constructor, destructor, or type conversion before '(' token
  683 | template<container_compatible_range<value_type> R> unordered_multimap(from_range_t, R&& rg,
      |                                                                      ^
p925.cpp:688:19: error: expected constructor, destructor, or type conversion before '(' token
  688 | unordered_multimap(initializer_list<value_type> il,
      |                   ^
p925.cpp:697:3: error: invalid use of template-name 'std::iterator' without an argument list
  697 |   iterator insert(P&& obj);
      |   ^~~~~~~~
p925.cpp:697:3: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:700:3: error: invalid use of template-name 'std::iterator' without an argument list
  700 |   iterator insert(const_iterator hint, P&& obj);
      |   ^~~~~~~~
p925.cpp:700:3: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++1'
/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
      |                                  ^~~~~~~~
p925.cpp:702:8: error: found ':' in nested-name-specifier, expected '::'
  702 | Effects: Equivalent to: return emplace_hint(hint, std::forward<P>(obj));
      |        ^
      |        ::
p925.cpp:702:1: error: 'Effects' does not name a type
  702 | Effects: Equivalent to: return emplace_hint(hint, std::forward<P>(obj));
      | ^~~~~~~
p925.cpp:705:12: error: expected nested-name-specifier before 'unordered_multimap'
  705 |   typename unordered_multimap<K, T, H, P, A>::size_type
      |            ^~~~~~~~~~~~~~~~~~
p925.cpp:705:30: error: expected initializer before '<' token
  705 |   typename unordered_multimap<K, T, H, P, A>::size_type
      |                              ^
p925.cpp:708:8: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
  708 |        auto original_size = c.size();
      |        ^~~~
      |        ----
p925.cpp:708:13: error: 'original_size' does not name a type
  708 |        auto original_size = c.size();
      |             ^~~~~~~~~~~~~
p925.cpp:709:8: error: expected unqualified-id before 'for'
  709 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |        ^~~
p925.cpp:709:49: error: 'i' does not name a type
  709 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                                 ^
p925.cpp:709:60: error: expected unqualified-id before ')' token
  709 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                                            ^
p925.cpp:714:8: error: expected unqualified-id before 'return'
  714 |        return original_size - c.size();
      |        ^~~~~~
p925.cpp:722:30: error: 'hash' does not name a type; did you mean 'Hash'?
  722 |                 class Hash = hash<Key>,
      |                              ^~~~
      |                              Hash
p925.cpp:722:34: error: expected '>' before '<' token
  722 |                 class Hash = hash<Key>,
      |                                  ^
p925.cpp:725:21: error: expected unqualified-id before '{' token
  725 | class unordered_set {
      |                     ^
p925.cpp:881:14: error: 'hash' does not name a type; did you mean 'Hash'?
  881 | class Hash = hash<iter_value_type<InputIterator>>,
      |              ^~~~
      |              Hash
p925.cpp:881:18: error: expected '>' before '<' token
  881 | class Hash = hash<iter_value_type<InputIterator>>,
      |                  ^
p925.cpp:885:72: error: expected unqualified-id before ';' token
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                                                        ^
p925.cpp:886:12: error: 'ranges' has not been declared
  886 |   template<ranges::input_range R,
      |            ^~~~~~
p925.cpp:886:32: error: expected '>' before 'R'
  886 |   template<ranges::input_range R,
      |                                ^
p925.cpp:891:68: error: expected unqualified-id before ';' token
  891 |                                      equal_range(const key_type& k);
      |                                                                    ^
p925.cpp:892:56: error: 'key_type' does not name a type; did you mean 'key_t'?
  892 |                                      equal_range(const key_type& k) const;
      |                                                        ^~~~~~~~
      |                                                        key_t
p925.cpp:892:74: error: expected constructor, destructor, or type conversion before ';' token
  892 |                                      equal_range(const key_type& k) const;
      |                                                                          ^
p925.cpp:893:56: error: 'K' does not name a type
  893 |                                      equal_range(const K& k);
      |                                                        ^
p925.cpp:893:61: error: expected constructor, destructor, or type conversion before ';' token
  893 |                                      equal_range(const K& k);
      |                                                             ^
p925.cpp:894:6: error: 'const_iterator' was not declared in this scope
  894 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |      ^~~~~~~~~~~~~~
p925.cpp:894:22: error: 'const_iterator' was not declared in this scope
  894 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                      ^~~~~~~~~~~~~~
p925.cpp:894:36: error: template argument 1 is invalid
  894 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                    ^
p925.cpp:894:36: error: template argument 2 is invalid
p925.cpp:894:56: error: 'K' does not name a type
  894 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                                        ^
p925.cpp:894:62: error: non-member function 'int pmr::std::equal_range(const int&)' cannot have cv-qualifier
  894 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                                              ^~~~~
p925.cpp:895:26: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  895 |   pair<iterator, iterator>
      |                          ^
p925.cpp:895:26: note:   expected a type, got 'iterator'
p925.cpp:895:26: error: type/value mismatch at argument 2 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
p925.cpp:895:26: note:   expected a type, got 'iterator'
p925.cpp:896:1: error: expected unqualified-id before 'template'
  896 | template<class K>
      | ^~~~~~~~
p925.cpp:900:39: error: 'hash' does not name a type; did you mean 'Hash'?
  900 |        template<class T, class Hash = hash<T>,
      |                                       ^~~~
      |                                       Hash
p925.cpp:900:43: error: expected '>' before '<' token
  900 |        template<class T, class Hash = hash<T>,
      |                                           ^
p925.cpp:903:54: error: expected unqualified-id before ';' token
  903 |            -> unordered_set<T, Hash, Pred, Allocator>;
      |                                                      ^
p925.cpp:905:54: error: expected nested-name-specifier before 'see'
  905 | unordered_set(InputIterator, InputIterator, typename see below::size_type, Allocator)
      |                                                      ^~~
p925.cpp:905:58: error: expected ',' or '...' before 'below'
  905 | unordered_set(InputIterator, InputIterator, typename see below::size_type, Allocator)
      |                                                          ^~~~~
p925.cpp:906:4: error: 'unordered_set' does not name a type; did you mean 'unordered_map'?
  906 | -> unordered_set<iter_value_type<InputIterator>, hash<iter_value_type <InputIterator>>,
      |    ^~~~~~~~~~~~~
      |    unordered_map
p925.cpp:906:17: error: expected constructor, destructor, or type conversion before '<' token
  906 | -> unordered_set<iter_value_type<InputIterator>, hash<iter_value_type <InputIterator>>,
      |                 ^
p925.cpp:908:113: error: expected nested-name-specifier before 'see'
  908 | ator, class Hash, class Allocator> unordered_set(InputIterator, InputIterator, typename see below::size_type,
      |                                                                                         ^~~

p925.cpp:908:117: error: expected ',' or '...' before 'below'
  908 | , class Hash, class Allocator> unordered_set(InputIterator, InputIterator, typename see below::size_type,
      |                                                                                         ^~~~~

p925.cpp:910:4: error: 'unordered_set' does not name a type; did you mean 'unordered_map'?
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |    ^~~~~~~~~~~~~
      |    unordered_map
p925.cpp:910:17: error: expected constructor, destructor, or type conversion before '<' token
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                 ^
p925.cpp:912:10: error: 'ranges' has not been declared
  912 | template<ranges::input_range R, class Allocator>
      |          ^~~~~~
p925.cpp:912:30: error: expected '>' before 'R'
  912 | template<ranges::input_range R, class Allocator>
      |                              ^
p925.cpp:913:14: error: expected constructor, destructor, or type conversion before '(' token
  913 | unordered_set(from_range_t, R&&, typename see below::size_type, Allocator)
      |              ^
p925.cpp:916:17: error: 'ranges' has not been declared
  916 |        template<ranges::input_range R, class Allocator>
      |                 ^~~~~~
p925.cpp:916:37: error: expected '>' before 'R'
  916 |        template<ranges::input_range R, class Allocator>
      |                                     ^
p925.cpp:917:23: error: expected constructor, destructor, or type conversion before '(' token
  917 |          unordered_set(from_range_t, R&&, Allocator)
      |                       ^
p925.cpp:920:10: error: 'ranges' has not been declared
  920 | template<ranges::input_range R, class Hash, class Allocator> unordered_set(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
      |          ^~~~~~
p925.cpp:920:30: error: expected '>' before 'R'
  920 | template<ranges::input_range R, class Hash, class Allocator> unordered_set(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
      |                              ^
p925.cpp:920:75: error: expected constructor, destructor, or type conversion before '(' token
  920 | template<ranges::input_range R, class Hash, class Allocator> unordered_set(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
      |                                                                           ^
p925.cpp:924:14: error: expected constructor, destructor, or type conversion before '(' token
  924 | unordered_set(initializer_list<T>, typename see below::size_type, Allocator)
      |              ^
p925.cpp:927:14: error: expected constructor, destructor, or type conversion before '(' token
  927 | unordered_set(initializer_list<T>, typename see below::size_type, Hash, Allocator)
      |              ^
p925.cpp:932:1: error: ISO C++ forbids declaration of 'unordered_set' with no type [-fpermissive]
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      | ^~~~~~~~~~~~~
p925.cpp: In function 'int pmr::unordered_set()':
p925.cpp:932:19: error: only constructors take member initializers
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                   ^~~~~~~~~~~~~
p925.cpp:932:43: error: 'see' was not declared in this scope
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                                           ^~~
p925.cpp:932:33: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                                 ^~~~~~~~~
      |                                 size_t
p925.cpp:932:57: warning: no return statement in function returning non-void [-Wreturn-type]
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                                                         ^
p925.cpp: At global scope:
p925.cpp:932:68: error: ISO C++ forbids declaration of 'unordered_set' with no type [-fpermissive]
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                                                                    ^~~~~~~~~~~~~
p925.cpp:932:59: error: 'explicit' outside class declaration
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                                                           ^~~~~~~~
p925.cpp:932:82: error: 'int pmr::unordered_set' redeclared as different kind of entity
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                                                                                  ^~~~~~~~~
p925.cpp:932:1: note: previous declaration 'int pmr::unordered_set()'
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      | ^~~~~~~~~~~~~
p925.cpp:932:82: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                                                                                  ^~~~~~~~~
      |                                                                                  size_t
p925.cpp:933:1: error: expected primary-expression before 'const'
  933 | const hasher& hf = hasher(),
      | ^~~~~
p925.cpp:934:1: error: expected primary-expression before 'const'
  934 | const key_equal& eql = key_equal(),
      | ^~~~~
p925.cpp:935:1: error: expected primary-expression before 'const'
  935 | const allocator_type& a = allocator_type());
      | ^~~~~
p925.cpp:938:1: error: 'size_type' has not been declared
  938 | size_type n = see below,
      | ^~~~~~~~~
p925.cpp:938:15: error: 'see' was not declared in this scope
  938 | size_type n = see below,
      |               ^~~
p925.cpp:938:19: error: expected ',' or '...' before 'below'
  938 | size_type n = see below,
      |                   ^~~~~
p925.cpp:941:44: error: expected constructor, destructor, or type conversion before ';' token
  941 | const allocator_type& a = allocator_type());
      |                                            ^
p925.cpp:942:10: error: 'container_compatible_range' has not been declared
  942 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp:942:36: error: expected '>' before '<' token
  942 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |                                    ^
p925.cpp:942:70: error: expected constructor, destructor, or type conversion before '(' token
  942 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |                                                                      ^
p925.cpp:947:14: error: expected constructor, destructor, or type conversion before '(' token
  947 | unordered_set(initializer_list<value_type> il, size_type n = see below,
      |              ^
p925.cpp:954:12: error: expected nested-name-specifier before 'unordered_set'
  954 |   typename unordered_set<K, H, P, A>::size_type
      |            ^~~~~~~~~~~~~
p925.cpp:954:25: error: expected initializer before '<' token
  954 |   typename unordered_set<K, H, P, A>::size_type
      |                         ^
p925.cpp:957:8: error: found ':' in nested-name-specifier, expected '::'
  957 | Effects: Equivalent to:
      |        ^
      |        ::
p925.cpp:957:1: error: 'Effects' does not name a type
  957 | Effects: Equivalent to:
      | ^~~~~~~
p925.cpp:959:8: error: expected unqualified-id before 'for'
  959 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |        ^~~
p925.cpp:959:49: error: 'i' does not name a type
  959 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                                 ^
p925.cpp:959:60: error: expected unqualified-id before ')' token
  959 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                                            ^
p925.cpp:964:8: error: expected unqualified-id before 'return'
  964 |        return original_size - c.size();
      |        ^~~~~~
p925.cpp:972:30: error: 'hash' does not name a type; did you mean 'Hash'?
  972 |                 class Hash = hash<Key>,
      |                              ^~~~
      |                              Hash
p925.cpp:972:34: error: expected '>' before '<' token
  972 |                 class Hash = hash<Key>,
      |                                  ^
p925.cpp:975:33: error: expected unqualified-id before '{' token
  975 |        class unordered_multiset {
      |                                 ^
p925.cpp:1132:14: error: 'hash' does not name a type; did you mean 'Hash'?
 1132 | class Hash = hash<iter_value_type<InputIterator>>,
      |              ^~~~
      |              Hash
p925.cpp:1132:18: error: expected '>' before '<' token
 1132 | class Hash = hash<iter_value_type<InputIterator>>,
      |                  ^
p925.cpp:1136:77: error: expected unqualified-id before ';' token
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                                                             ^
p925.cpp:1137:10: error: 'ranges' has not been declared
 1137 | template<ranges::input_range R,
      |          ^~~~~~
p925.cpp:1137:30: error: expected '>' before 'R'
 1137 | template<ranges::input_range R,
      |                              ^
p925.cpp:1142:68: error: expected unqualified-id before ';' token
 1142 |                                      equal_range(const key_type& k);
      |                                                                    ^
p925.cpp:1143:56: error: 'key_type' does not name a type; did you mean 'key_t'?
 1143 |                                      equal_range(const key_type& k) const;
      |                                                        ^~~~~~~~
      |                                                        key_t
p925.cpp:1143:74: error: expected constructor, destructor, or type conversion before ';' token
 1143 |                                      equal_range(const key_type& k) const;
      |                                                                          ^
p925.cpp:1144:56: error: 'K' does not name a type
 1144 |                                      equal_range(const K& k);
      |                                                        ^
p925.cpp:1144:61: error: expected constructor, destructor, or type conversion before ';' token
 1144 |                                      equal_range(const K& k);
      |                                                             ^
p925.cpp:1145:6: error: 'const_iterator' was not declared in this scope
 1145 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |      ^~~~~~~~~~~~~~
p925.cpp:1145:22: error: 'const_iterator' was not declared in this scope
 1145 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                      ^~~~~~~~~~~~~~
p925.cpp:1145:36: error: template argument 1 is invalid
 1145 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                    ^
p925.cpp:1145:36: error: template argument 2 is invalid
p925.cpp:1145:56: error: 'K' does not name a type
 1145 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                                        ^
p925.cpp:1145:62: error: non-member function 'int pmr::std::equal_range(const int&)' cannot have cv-qualifier
 1145 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                                              ^~~~~
p925.cpp:1146:26: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
 1146 |   pair<iterator, iterator>
      |                          ^
p925.cpp:1146:26: note:   expected a type, got 'iterator'
p925.cpp:1146:26: error: type/value mismatch at argument 2 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
p925.cpp:1146:26: note:   expected a type, got 'iterator'
p925.cpp:1147:1: error: expected unqualified-id before 'template'
 1147 | template<class K>
      | ^~~~~~~~
p925.cpp:1150:39: error: 'hash' does not name a type; did you mean 'Hash'?
 1150 |        template<class T, class Hash = hash<T>,
      |                                       ^~~~
      |                                       Hash
p925.cpp:1150:43: error: expected '>' before '<' token
 1150 |        template<class T, class Hash = hash<T>,
      |                                           ^
p925.cpp:1153:59: error: expected unqualified-id before ';' token
 1153 |            -> unordered_multiset<T, Hash, Pred, Allocator>;
      |                                                           ^
p925.cpp:1155:59: error: expected nested-name-specifier before 'see'
 1155 | unordered_multiset(InputIterator, InputIterator, typename see below::size_type, Allocator)
      |                                                           ^~~
p925.cpp:1155:63: error: expected ',' or '...' before 'below'
 1155 | unordered_multiset(InputIterator, InputIterator, typename see below::size_type, Allocator)
      |                                                               ^~~~~
p925.cpp:1156:4: error: 'unordered_multiset' does not name a type
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |    ^~~~~~~~~~~~~~~~~~
p925.cpp:1156:22: error: expected constructor, destructor, or type conversion before '<' token
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                      ^
p925.cpp:1158:118: error: expected nested-name-specifier before 'see'
 1158 |  class Hash, class Allocator> unordered_multiset(InputIterator, InputIterator, typename see below::size_type,
      |                                                                                         ^~~

p925.cpp:1158:122: error: expected ',' or '...' before 'below'
 1158 | ss Hash, class Allocator> unordered_multiset(InputIterator, InputIterator, typename see below::size_type,
      |                                                                                         ^~~~~

p925.cpp:1160:4: error: 'unordered_multiset' does not name a type
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |    ^~~~~~~~~~~~~~~~~~
p925.cpp:1160:22: error: expected constructor, destructor, or type conversion before '<' token
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                      ^
p925.cpp:1162:10: error: 'ranges' has not been declared
 1162 | template<ranges::input_range R, class Allocator>
      |          ^~~~~~
p925.cpp:1162:30: error: expected '>' before 'R'
 1162 | template<ranges::input_range R, class Allocator>
      |                              ^
p925.cpp:1163:19: error: expected constructor, destructor, or type conversion before '(' token
 1163 | unordered_multiset(from_range_t, R&&, typename see_below::size_type, Allocator)
      |                   ^
p925.cpp:1166:17: error: 'ranges' has not been declared
 1166 |        template<ranges::input_range R, class Allocator>
      |                 ^~~~~~
p925.cpp:1166:37: error: expected '>' before 'R'
 1166 |        template<ranges::input_range R, class Allocator>
      |                                     ^
p925.cpp:1167:28: error: expected constructor, destructor, or type conversion before '(' token
 1167 |          unordered_multiset(from_range_t, R&&, Allocator)
      |                            ^
p925.cpp:1170:10: error: 'ranges' has not been declared
 1170 | template<ranges::input_range R, class Hash, class Allocator> unordered_multiset(from_range_t, R&&, typename see_below::size_type, Hash, Allocator)
      |          ^~~~~~
p925.cpp:1170:30: error: expected '>' before 'R'
 1170 | template<ranges::input_range R, class Hash, class Allocator> unordered_multiset(from_range_t, R&&, typename see_below::size_type, Hash, Allocator)
      |                              ^
p925.cpp:1170:80: error: expected constructor, destructor, or type conversion before '(' token
 1170 | template<ranges::input_range R, class Hash, class Allocator> unordered_multiset(from_range_t, R&&, typename see_below::size_type, Hash, Allocator)
      |                                                                                ^
p925.cpp:1174:19: error: expected constructor, destructor, or type conversion before '(' token
 1174 | unordered_multiset(initializer_list<T>, typename see_below::size_type, Allocator)
      |                   ^
p925.cpp:1177:19: error: expected constructor, destructor, or type conversion before '(' token
 1177 | unordered_multiset(initializer_list<T>, typename see_below::size_type, Hash, Allocator)
      |                   ^
p925.cpp:1182:1: error: ISO C++ forbids declaration of 'unordered_multiset' with no type [-fpermissive]
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      | ^~~~~~~~~~~~~~~~~~
p925.cpp: In function 'int pmr::unordered_multiset()':
p925.cpp:1182:24: error: only constructors take member initializers
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                        ^~~~~~~~~~~~~~~~~~
p925.cpp:1182:53: error: 'see_below' was not declared in this scope
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                                                     ^~~~~~~~~
p925.cpp:1182:43: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                                           ^~~~~~~~~
      |                                           size_t
p925.cpp:1182:67: warning: no return statement in function returning non-void [-Wreturn-type]
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                                                                   ^
p925.cpp: At global scope:
p925.cpp:1182:78: error: ISO C++ forbids declaration of 'unordered_multiset' with no type [-fpermissive]
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                                                                              ^~~~~~~~~~~~~~~~~~
p925.cpp:1182:69: error: 'explicit' outside class declaration
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                                                                     ^~~~~~~~
p925.cpp:1182:97: error: 'int pmr::unordered_multiset' redeclared as different kind of entity
 1182 | d_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                                                                                         ^~~~~~~~~

p925.cpp:1182:1: note: previous declaration 'int pmr::unordered_multiset()'
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      | ^~~~~~~~~~~~~~~~~~
p925.cpp:1182:97: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
 1182 | d_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                                                                                         ^~~~~~~~~
      |                                                                                         size_t
p925.cpp:1183:1: error: expected primary-expression before 'const'
 1183 | const hasher& hf = hasher(),
      | ^~~~~
p925.cpp:1184:1: error: expected primary-expression before 'const'
 1184 | const key_equal& eql = key_equal(),
      | ^~~~~
p925.cpp:1185:1: error: expected primary-expression before 'const'
 1185 | const allocator_type& a = allocator_type());
      | ^~~~~
p925.cpp:1188:1: error: 'size_type' has not been declared
 1188 | size_type n = see_below,
      | ^~~~~~~~~
p925.cpp:1188:15: error: 'see_below' was not declared in this scope
 1188 | size_type n = see_below,
      |               ^~~~~~~~~
p925.cpp:1189:7: error: 'hasher' does not name a type
 1189 | const hasher& hf = hasher(),
      |       ^~~~~~
p925.cpp:1189:20: error: there are no arguments to 'hasher' that depend on a template parameter, so a declaration of 'hasher' must be available [-fpermissive]
 1189 | const hasher& hf = hasher(),
      |                    ^~~~~~
p925.cpp:1190:7: error: 'key_equal' does not name a type
 1190 | const key_equal& eql = key_equal(),
      |       ^~~~~~~~~
p925.cpp:1190:24: error: there are no arguments to 'key_equal' that depend on a template parameter, so a declaration of 'key_equal' must be available [-fpermissive]
 1190 | const key_equal& eql = key_equal(),
      |                        ^~~~~~~~~
p925.cpp:1191:7: error: 'allocator_type' does not name a type
 1191 | const allocator_type& a = allocator_type());
      |       ^~~~~~~~~~~~~~
p925.cpp:1191:27: error: there are no arguments to 'allocator_type' that depend on a template parameter, so a declaration of 'allocator_type' must be available [-fpermissive]
 1191 | const allocator_type& a = allocator_type());
      |                           ^~~~~~~~~~~~~~
p925.cpp:1191:44: error: expected constructor, destructor, or type conversion before ';' token
 1191 | const allocator_type& a = allocator_type());
      |                                            ^
p925.cpp:1192:10: error: 'container_compatible_range' has not been declared
 1192 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp:1192:36: error: expected '>' before '<' token
 1192 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |                                    ^
p925.cpp:1192:70: error: expected constructor, destructor, or type conversion before '(' token
 1192 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |                                                                      ^
p925.cpp:1197:19: error: expected constructor, destructor, or type conversion before '(' token
 1197 | unordered_multiset(initializer_list<value_type> il, size_type n = see_below,
      |                   ^
p925.cpp:1205:12: error: expected nested-name-specifier before 'unordered_multiset'
 1205 |   typename unordered_multiset<K, H, P, A>::size_type
      |            ^~~~~~~~~~~~~~~~~~
p925.cpp:1205:30: error: expected initializer before '<' token
 1205 |   typename unordered_multiset<K, H, P, A>::size_type
      |                              ^
p925.cpp:1208:4: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
 1208 |    auto original_size = c.size();
      |    ^~~~
      |    ----
p925.cpp:1208:9: error: 'original_size' does not name a type
 1208 |    auto original_size = c.size();
      |         ^~~~~~~~~~~~~
p925.cpp:1209:4: error: expected unqualified-id before 'for'
 1209 |    for (auto i = c.begin(), last = c.end(); i != last; ) {
      |    ^~~
p925.cpp:1209:45: error: 'i' does not name a type
 1209 |    for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                             ^
p925.cpp:1209:56: error: expected unqualified-id before ')' token
 1209 |    for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                                        ^
p925.cpp:1214:4: error: expected unqualified-id before 'return'
 1214 |    return original_size - c.size();
      |    ^~~~~~
p925.cpp: In function 'int pmr::main()':
p925.cpp:1217:13: error: 'n4910' was not declared in this scope
 1217 |   cout  <<  n4910 << endl;
      |             ^~~~~
p925.cpp: At global scope:
p925.cpp:1219:2: error: expected '}' at end of input
 1219 | }
      |  ^
p925.cpp:55:15: note: to match this '{'
   55 | namespace pmr {
      |               ^

$ g++ p925.cpp -std=2b -o p925g -I. -Wall
p925.cpp:1:1: error: stray '`' in program
    1 | ```c++:p925.cpp
      | ^
p925.cpp:1:2: error: stray '`' in program
    1 | ```c++:p925.cpp
      |  ^
p925.cpp:1:3: error: stray '`' in program
    1 | ```c++:p925.cpp
      |   ^
p925.cpp:337:18: error: stray '\' in program
  337 | template<ranges::\tcode{input_range} R, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Allocator)
      |                  ^
p925.cpp:897:252: error: too many decimal points in number
  897 | efault constructor, the number of buckets is implementation-defined. max_load_factor() returns 1.0.
      |                                                                                                ^~~~

p925.cpp:1:4: error: 'c' does not name a type
    1 | ```c++:p925.cpp
      |    ^
p925.cpp:23:24: error: expected unqualified-id before ',' token
   23 |                 class T,
      |                        ^
p925.cpp:24:17: error: expected unqualified-id before 'class'
   24 |                 class Hash = hash<Key>,
      |                 ^~~~~
p925.cpp:29:24: error: expected unqualified-id before ',' token
   29 |                 class T,
      |                        ^
p925.cpp:30:17: error: expected unqualified-id before 'class'
   30 |                 class Hash = hash<Key>,
      |                 ^~~~~
p925.cpp:54:3: error: expected declaration before '}' token
   54 | } }
      |   ^
p925.cpp:62:26: error: 'polymorphic_allocator' was not declared in this scope; did you mean 'std::pmr::polymorphic_allocator'?
   62 |                          polymorphic_allocator<pair<const Key, T>>>;
      |                          ^~~~~~~~~~~~~~~~~~~~~
      |                          std::pmr::polymorphic_allocator
In file included from /usr/local/include/c++/12.1.0/bits/locale_classes.h:40,
                 from /usr/local/include/c++/12.1.0/bits/ios_base.h:41,
                 from /usr/local/include/c++/12.1.0/ios:42,
                 from /usr/local/include/c++/12.1.0/ostream:38,
                 from /usr/local/include/c++/12.1.0/iostream:39,
                 from N4910.h:2,
                 from p925.cpp:11:
/usr/local/include/c++/12.1.0/string:61:34: note: 'std::pmr::polymorphic_allocator' declared here
   61 |     template<typename _Tp> class polymorphic_allocator;
      |                                  ^~~~~~~~~~~~~~~~~~~~~
p925.cpp:62:65: error: template argument 5 is invalid
   62 |                          polymorphic_allocator<pair<const Key, T>>>;
      |                                                                 ^~
p925.cpp:61:12: error: '<expression error>' in namespace 'std' does not name a type
   61 |       std::unordered_map<Key, T, Hash, Pred,
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   62 |                          polymorphic_allocator<pair<const Key, T>>>;
      |                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp:69:33: error: 'polymorphic_allocator' was not declared in this scope; did you mean 'std::pmr::polymorphic_allocator'?
   69 |                                 polymorphic_allocator<pair<const Key, T>>>;
      |                                 ^~~~~~~~~~~~~~~~~~~~~
      |                                 std::pmr::polymorphic_allocator
/usr/local/include/c++/12.1.0/string:61:34: note: 'std::pmr::polymorphic_allocator' declared here
   61 |     template<typename _Tp> class polymorphic_allocator;
      |                                  ^~~~~~~~~~~~~~~~~~~~~
p925.cpp:69:72: error: template argument 5 is invalid
   69 |                                 polymorphic_allocator<pair<const Key, T>>>;
      |                                                                        ^~
p925.cpp:68:14: error: '<expression error>' in namespace 'std' does not name a type
   68 |         std::unordered_multimap<Key, T, Hash, Pred,
      |              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   69 |                                 polymorphic_allocator<pair<const Key, T>>>;
      |                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp:75:23: error: expected unqualified-id before '=' token
   75 |            class Hash = hash<Key>,
      |                       ^
p925.cpp:80:23: error: expected unqualified-id before '=' token
   80 |            class Hash = hash<Key>,
      |                       ^
p925.cpp:85:27: error: 'unordered_set' does not name a type
   85 |     bool operator==(const unordered_set<Key, Hash, Pred, Alloc>& a,
      |                           ^~~~~~~~~~~~~
p925.cpp:85:40: error: expected ',' or '...' before '<' token
   85 |     bool operator==(const unordered_set<Key, Hash, Pred, Alloc>& a,
      |                                        ^
p925.cpp:85:10: error: 'bool pmr::std::operator==(int)' must have an argument of class or enumerated type
   85 |     bool operator==(const unordered_set<Key, Hash, Pred, Alloc>& a,
      |          ^~~~~~~~
p925.cpp:88:27: error: 'unordered_multiset' does not name a type
   88 |     bool operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
      |                           ^~~~~~~~~~~~~~~~~~
p925.cpp:88:45: error: expected ',' or '...' before '<' token
   88 |     bool operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
      |                                             ^
p925.cpp:88:10: error: 'bool pmr::std::operator==(int)' must have an argument of class or enumerated type
   88 |     bool operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
      |          ^~~~~~~~
p925.cpp:91:10: error: variable or field 'swap' declared void
   91 |     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
      |          ^~~~
p925.cpp:91:15: error: 'unordered_set' was not declared in this scope
   91 |     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
      |               ^~~~~~~~~~~~~
p925.cpp:12:1: note: 'std::unordered_set' is defined in header '<unordered_set>'; did you forget to '#include <unordered_set>'?
   11 | #include "N4910.h"
  +++ |+#include <unordered_set>
   12 | 
p925.cpp:91:32: error: expected primary-expression before ',' token
   91 |     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
      |                                ^
p925.cpp:91:38: error: expected primary-expression before ',' token
   91 |     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
      |                                      ^
p925.cpp:91:44: error: expected primary-expression before ',' token
   91 |     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
      |                                            ^
p925.cpp:91:51: error: expected primary-expression before '>' token
   91 |     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
      |                                                   ^
p925.cpp:91:54: error: 'x' was not declared in this scope
   91 |     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
      |                                                      ^
p925.cpp:92:15: error: 'unordered_set' was not declared in this scope
   92 |               unordered_set<Key, Hash, Pred, Alloc>& y)
      |               ^~~~~~~~~~~~~
p925.cpp:92:15: note: 'std::unordered_set' is defined in header '<unordered_set>'; did you forget to '#include <unordered_set>'?
p925.cpp:92:32: error: expected primary-expression before ',' token
   92 |               unordered_set<Key, Hash, Pred, Alloc>& y)
      |                                ^
p925.cpp:92:38: error: expected primary-expression before ',' token
   92 |               unordered_set<Key, Hash, Pred, Alloc>& y)
      |                                      ^
p925.cpp:92:44: error: expected primary-expression before ',' token
   92 |               unordered_set<Key, Hash, Pred, Alloc>& y)
      |                                            ^
p925.cpp:92:51: error: expected primary-expression before '>' token
   92 |               unordered_set<Key, Hash, Pred, Alloc>& y)
      |                                                   ^
p925.cpp:92:54: error: 'y' was not declared in this scope; did you mean 'yn'?
   92 |               unordered_set<Key, Hash, Pred, Alloc>& y)
      |                                                      ^
      |                                                      yn
p925.cpp:95:10: error: variable or field 'swap' declared void
   95 |     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
      |          ^~~~
p925.cpp:95:15: error: 'unordered_multiset' was not declared in this scope
   95 |     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
      |               ^~~~~~~~~~~~~~~~~~
p925.cpp:95:15: note: 'std::unordered_multiset' is defined in header '<unordered_set>'; did you forget to '#include <unordered_set>'?
p925.cpp:95:37: error: expected primary-expression before ',' token
   95 |     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
      |                                     ^
p925.cpp:95:43: error: expected primary-expression before ',' token
   95 |     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
      |                                           ^
p925.cpp:95:49: error: expected primary-expression before ',' token
   95 |     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
      |                                                 ^
p925.cpp:95:56: error: expected primary-expression before '>' token
   95 |     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
      |                                                        ^
p925.cpp:95:59: error: 'x' was not declared in this scope
   95 |     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
      |                                                           ^
p925.cpp:96:15: error: 'unordered_multiset' was not declared in this scope
   96 |               unordered_multiset<Key, Hash, Pred, Alloc>& y)
      |               ^~~~~~~~~~~~~~~~~~
p925.cpp:96:15: note: 'std::unordered_multiset' is defined in header '<unordered_set>'; did you forget to '#include <unordered_set>'?
p925.cpp:96:37: error: expected primary-expression before ',' token
   96 |               unordered_multiset<Key, Hash, Pred, Alloc>& y)
      |                                     ^
p925.cpp:96:43: error: expected primary-expression before ',' token
   96 |               unordered_multiset<Key, Hash, Pred, Alloc>& y)
      |                                           ^
p925.cpp:96:49: error: expected primary-expression before ',' token
   96 |               unordered_multiset<Key, Hash, Pred, Alloc>& y)
      |                                                 ^
p925.cpp:96:56: error: expected primary-expression before '>' token
   96 |               unordered_multiset<Key, Hash, Pred, Alloc>& y)
      |                                                        ^
p925.cpp:96:59: error: 'y' was not declared in this scope; did you mean 'yn'?
   96 |               unordered_multiset<Key, Hash, Pred, Alloc>& y)
      |                                                           ^
      |                                                           yn
p925.cpp:99:14: error: expected nested-name-specifier before 'unordered_set'
   99 |     typename unordered_set<K, H, P, A>::size_type
      |              ^~~~~~~~~~~~~
p925.cpp:99:27: error: expected initializer before '<' token
   99 |     typename unordered_set<K, H, P, A>::size_type
      |                           ^
p925.cpp:102:14: error: expected nested-name-specifier before 'unordered_multiset'
  102 |     typename unordered_multiset<K, H, P, A>::size_type
      |              ^~~~~~~~~~~~~~~~~~
p925.cpp:102:32: error: expected initializer before '<' token
  102 |     typename unordered_multiset<K, H, P, A>::size_type
      |                                ^
p925.cpp:108:32: error: 'unordered_set' in namespace 'pmr::std' does not name a template type
  108 |     using unordered_set = std::unordered_set<Key, Hash, Pred,
      |                                ^~~~~~~~~~~~~
p925.cpp:113:37: error: 'unordered_multiset' in namespace 'pmr::std' does not name a template type
  113 |     using unordered_multiset = std::unordered_multiset<Key, Hash, Pred,
      |                                     ^~~~~~~~~~~~~~~~~~
p925.cpp:120:1: error: 'tables' does not name a type
  120 | tables, or for which there is additional semantic information.
      | ^~~~~~
p925.cpp:131:20: error: 'Key' does not name a type
  131 |   using key_type = Key;
      |                    ^~~
p925.cpp:133:33: error: ISO C++ forbids declaration of 'type name' with no type [-fpermissive]
  133 |   using value_type = pair<const Key, T>;
      |                                 ^~~
p925.cpp:133:39: error: wrong number of template arguments (1, should be 2)
  133 |   using value_type = pair<const Key, T>;
      |                                       ^
In file included from /usr/local/include/c++/12.1.0/string:47:
/usr/local/include/c++/12.1.0/bits/stl_iterator.h:2547:12: note: provided for 'template<class _T1, class _T2> struct std::pair'
 2547 |     struct pair;
      |            ^~~~
p925.cpp:135:21: error: 'Pred' does not name a type
  135 |   using key_equal = Pred;
      |                     ^~~~
p925.cpp:136:26: error: 'Allocator' does not name a type; did you mean 'alloca'?
  136 |   using allocator_type = Allocator;
      |                          ^~~~~~~~~
      |                          alloca
p925.cpp:137:45: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  137 |   using pointer = typename allocator_traits<Allocator>::pointer;
      |                                             ^~~~~~~~~
      |                                             alloca
p925.cpp:137:54: error: template argument 1 is invalid
  137 |   using pointer = typename allocator_traits<Allocator>::pointer;
      |                                                      ^
p925.cpp:138:51: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  138 |   using const_pointer = typename allocator_traits<Allocator>::const_pointer;
      |                                                   ^~~~~~~~~
      |                                                   alloca
p925.cpp:138:60: error: template argument 1 is invalid
  138 |   using const_pointer = typename allocator_traits<Allocator>::const_pointer;
      |                                                            ^
p925.cpp:139:22: error: 'value_type' does not name a type
  139 |   using reference  = value_type&;
      |                      ^~~~~~~~~~
p925.cpp:140:33: error: ISO C++ forbids declaration of 'type name' with no type [-fpermissive]
  140 |   using const_reference = const value_type&;
      |                                 ^~~~~~~~~~
p925.cpp:140:32: error: expected ';' before 'value_type'
  140 |   using const_reference = const value_type&;
      |                                ^~~~~~~~~~~
      |                                ;
p925.cpp:141:21: error: 'implementation_defined' does not name a type
  141 |   using size_type = implementation_defined ; // see 24.2
      |                     ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:142:27: error: 'implementation_defined' does not name a type
  142 |   using difference_type = implementation_defined ; // see 24.2
      |                           ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:143:20: error: 'implementation_defined' does not name a type
  143 |   using iterator = implementation_defined ; // see 24.2
      |                    ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:144:26: error: 'implementation_defined' does not name a type
  144 |   using const_iterator = implementation_defined ; // see 24.2
      |                          ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:145:26: error: 'implementation_defined' does not name a type
  145 |   using local_iterator = implementation_defined ; // see 24.2
      |                          ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:146:32: error: 'implementation_defined' does not name a type
  146 |   using const_local_iterator = implementation_defined ; // see 24.2
      |                                ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:147:21: error: 'unspecified' does not name a type
  147 |   using node_type = unspecified;
      |                     ^~~~~~~~~~~
p925.cpp:148:30: error: 'insert' does not name a type; did you mean 'assert'?
  148 |   using insert_return_type = insert-return-type<iterator, node_type>; // // 24.5.4.2, construct/copy/destroy
      |                              ^~~~~~
      |                              assert
p925.cpp:150:33: error: expected ')' before 'n'
  150 | explicit unordered_map(size_type n,
      |                       ~         ^~
      |                                 )
p925.cpp:155:49: error: 'size_type' has not been declared
  155 | unordered_map(InputIterator f, InputIterator l, size_type n = see below,
      |                                                 ^~~~~~~~~
p925.cpp:157:23: error: 'key_equal' does not name a type
  157 |                 const key_equal& eql = key_equal(),
      |                       ^~~~~~~~~
p925.cpp:158:23: error: 'allocator_type' does not name a type
  158 |                 const allocator_type& a = allocator_type());
      |                       ^~~~~~~~~~~~~~
p925.cpp:159:10: error: 'container' has not been declared
  159 | template<container-compatible-range<value_type> R> unordered_map(from_range_t, R&& rg, size_type n = see below,
      |          ^~~~~~~~~
p925.cpp:159:19: error: expected '>' before '-' token
  159 | template<container-compatible-range<value_type> R> unordered_map(from_range_t, R&& rg, size_type n = see below,
      |                   ^
p925.cpp:159:78: error: expected ')' before ',' token
  159 | template<container-compatible-range<value_type> R> unordered_map(from_range_t, R&& rg, size_type n = see below,
      |                                                                 ~            ^
      |                                                                              )
p925.cpp:164:30: error: 'Allocator' does not name a type; did you mean 'alloca'?
  164 | explicit unordered_map(const Allocator&);
      |                              ^~~~~~~~~
      |                              alloca
p925.cpp:165:59: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  165 | unordered_map(const unordered_map&, const type_identity_t<Allocator>&);
      |                                                           ^~~~~~~~~
      |                                                           alloca
p925.cpp:165:68: error: template argument 1 is invalid
  165 | unordered_map(const unordered_map&, const type_identity_t<Allocator>&);
      |                                                                    ^
p925.cpp:166:54: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  166 | unordered_map(unordered_map&&, const type_identity_t<Allocator>&);
      |                                                      ^~~~~~~~~
      |                                                      alloca
p925.cpp:166:63: error: template argument 1 is invalid
  166 | unordered_map(unordered_map&&, const type_identity_t<Allocator>&);
      |                                                               ^
p925.cpp:167:32: error: 'value_type' was not declared in this scope
  167 | unordered_map(initializer_list<value_type> il,
      |                                ^~~~~~~~~~
p925.cpp:167:42: error: template argument 1 is invalid
  167 | unordered_map(initializer_list<value_type> il,
      |                                          ^
p925.cpp:168:1: error: 'size_type' has not been declared
  168 | size_type n = see below,
      | ^~~~~~~~~
p925.cpp:170:7: error: 'key_equal' does not name a type
  170 | const key_equal& eql = key_equal(),
      |       ^~~~~~~~~
p925.cpp:171:7: error: 'allocator_type' does not name a type
  171 | const allocator_type& a = allocator_type());
      |       ^~~~~~~~~~~~~~
p925.cpp:172:24: error: expected ')' before 'n'
  172 | unordered_map(size_type n, const allocator_type& a)
      |              ~         ^~
      |                        )
p925.cpp:174:24: error: expected ')' before 'n'
  174 | unordered_map(size_type n, const hasher& hf, const allocator_type& a)
      |              ~         ^~
      |                        )
p925.cpp:177:51: error: 'size_type' has not been declared
  177 |   unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
      |                                                   ^~~~~~~~~
p925.cpp:177:70: error: 'allocator_type' does not name a type
  177 |   unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
      |                                                                      ^~~~~~~~~~~~~~
p925.cpp:180:51: error: 'size_type' has not been declared
  180 |   unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,
      |                                                   ^~~~~~~~~
p925.cpp:181:23: error: 'allocator_type' does not name a type
  181 |                 const allocator_type& a)
      |                       ^~~~~~~~~~~~~~
p925.cpp:182:59: error: 'container' has not been declared
  182 | : unordered_map(f, l, n, hf, key_equal(), a) { } template<container-compatible-range<value_type> R>
      |                                                           ^~~~~~~~~
p925.cpp:182:68: error: expected '>' before '-' token
  182 | : unordered_map(f, l, n, hf, key_equal(), a) { } template<container-compatible-range<value_type> R>
      |                                                                    ^
p925.cpp:183:29: error: expected ')' before ',' token
  183 |   unordered_map(from_range_t, R&& rg, size_type n, const allocator_type& a)
      |                ~            ^
      |                             )
p925.cpp:185:10: error: 'container' has not been declared
  185 | template<container-compatible-range<value_type> R>
      |          ^~~~~~~~~
p925.cpp:185:19: error: expected '>' before '-' token
  185 | template<container-compatible-range<value_type> R>
      |                   ^
p925.cpp:186:27: error: expected ')' before ',' token
  186 | unordered_map(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
      |              ~            ^
      |                           )
p925.cpp:188:32: error: 'value_type' was not declared in this scope
  188 | unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
      |                                ^~~~~~~~~~
p925.cpp:188:42: error: template argument 1 is invalid
  188 | unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
      |                                          ^
p925.cpp:188:48: error: 'size_type' has not been declared
  188 | unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
      |                                                ^~~~~~~~~
p925.cpp:188:67: error: 'allocator_type' does not name a type
  188 | unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
      |                                                                   ^~~~~~~~~~~~~~
p925.cpp:190:32: error: 'value_type' was not declared in this scope
  190 | unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf,
      |                                ^~~~~~~~~~
p925.cpp:190:42: error: template argument 1 is invalid
  190 | unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf,
      |                                          ^
p925.cpp:190:48: error: 'size_type' has not been declared
  190 | unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf,
      |                                                ^~~~~~~~~
p925.cpp:191:21: error: 'allocator_type' does not name a type
  191 |               const allocator_type& a)
      |                     ^~~~~~~~~~~~~~
p925.cpp:198:43: error: 'value_type' was not declared in this scope
  198 | unordered_map& operator=(initializer_list<value_type>);
      |                                           ^~~~~~~~~~
p925.cpp:198:53: error: template argument 1 is invalid
  198 | unordered_map& operator=(initializer_list<value_type>);
      |                                                     ^
p925.cpp:199:1: error: 'allocator_type' does not name a type
  199 | allocator_type get_allocator() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:201:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  201 | 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
      |                                  ^~~~~~~~
p925.cpp:201:1: error: deduced class type 'iterator' in function return type
  201 | 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
      |                                  ^~~~~~~~
p925.cpp:202:1: error: 'const_iterator' does not name a type
  202 | const_iterator begin() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:203:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  203 | 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
      |                                  ^~~~~~~~
p925.cpp:203:1: error: deduced class type 'iterator' in function return type
  203 | 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
      |                                  ^~~~~~~~
p925.cpp:204:1: error: 'const_iterator' does not name a type
  204 | const_iterator end() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:205:1: error: 'const_iterator' does not name a type
  205 | const_iterator cbegin() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:206:1: error: 'const_iterator' does not name a type
  206 | const_iterator cend() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:209:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  209 | size_type size() const noexcept;
      | ^~~~~~~~~
      | size_t
p925.cpp:210:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  210 | size_type max_size() const noexcept;
      | ^~~~~~~~~
      | size_t
p925.cpp:212:30: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  212 | template<class... Args> pair<iterator, bool> emplace(Args&&... args);
      |                              ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:212:44: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  212 | template<class... Args> pair<iterator, bool> emplace(Args&&... args);
      |                                            ^
p925.cpp:212:44: note:   expected a type, got 'iterator'
p925.cpp:213:25: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  213 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
      |                         ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:213:47: error: 'const_iterator' has not been declared
  213 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
      |                                               ^~~~~~~~~~~~~~
p925.cpp:213:25: error: deduced class type 'iterator' in function return type
  213 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
      |                         ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:213:94: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  213 | ate<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
      |                                                                                         ^~~~~~~~

/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:213:108: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  213 | rgs> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
      |                                                                                         ^

p925.cpp:213:108: note:   expected a type, got 'iterator'
p925.cpp:213:123: error: 'value_type' does not name a type
  213 | mplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
      |                                                                                         ^~~~~~~~~~

p925.cpp:214:6: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  214 | pair<iterator, bool> insert(value_type&& obj);
      |      ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:214:20: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  214 | pair<iterator, bool> insert(value_type&& obj);
      |                    ^
p925.cpp:214:20: note:   expected a type, got 'iterator'
p925.cpp:214:29: error: 'value_type' has not been declared
  214 | pair<iterator, bool> insert(value_type&& obj);
      |                             ^~~~~~~~~~
p925.cpp:215:24: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  215 | template<class P> pair<iterator, bool> insert(P&& obj);
      |                        ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:215:38: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  215 | template<class P> pair<iterator, bool> insert(P&& obj);
      |                                      ^
p925.cpp:215:38: note:   expected a type, got 'iterator'
p925.cpp:216:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  216 | iterator insert(const_iterator hint, const value_type& obj);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:216:17: error: 'const_iterator' has not been declared
  216 | iterator insert(const_iterator hint, const value_type& obj);
      |                 ^~~~~~~~~~~~~~
p925.cpp:216:44: error: 'value_type' does not name a type
  216 | iterator insert(const_iterator hint, const value_type& obj);
      |                                            ^~~~~~~~~~
p925.cpp:216:1: error: deduced class type 'iterator' in function return type
  216 | iterator insert(const_iterator hint, const value_type& obj);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:217:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  217 | iterator insert(const_iterator hint, value_type&& obj);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:217:17: error: 'const_iterator' has not been declared
  217 | iterator insert(const_iterator hint, value_type&& obj);
      |                 ^~~~~~~~~~~~~~
p925.cpp:217:38: error: 'value_type' has not been declared
  217 | iterator insert(const_iterator hint, value_type&& obj);
      |                                      ^~~~~~~~~~
p925.cpp:217:1: error: deduced class type 'iterator' in function return type
  217 | iterator insert(const_iterator hint, value_type&& obj);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:218:19: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  218 | template<class P> iterator insert(const_iterator hint, P&& obj);
      |                   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:218:35: error: 'const_iterator' has not been declared
  218 | template<class P> iterator insert(const_iterator hint, P&& obj);
      |                                   ^~~~~~~~~~~~~~
p925.cpp:218:19: error: deduced class type 'iterator' in function return type
  218 | template<class P> iterator insert(const_iterator hint, P&& obj);
      |                   ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:219:94: error: 'container' has not been declared
  219 | ate<class InputIterator> void insert(InputIterator first, InputIterator last); template<container-compatible-range<value_type> R>
      |                                                                                         ^~~~~~~~~

p925.cpp:219:103: error: expected '>' before '-' token
  219 |  InputIterator> void insert(InputIterator first, InputIterator last); template<container-compatible-range<value_type> R>
      |                                                                                         ^

p925.cpp:220:21: error: 'R' has not been declared
  220 |   void insert_range(R&& rg);
      |                     ^
p925.cpp:221:30: error: 'value_type' was not declared in this scope
  221 | void insert(initializer_list<value_type>);
      |                              ^~~~~~~~~~
p925.cpp:221:40: error: template argument 1 is invalid
  221 | void insert(initializer_list<value_type>);
      |                                        ^
p925.cpp:222:1: error: 'node_type' does not name a type
  222 | node_type extract(const_iterator position);
      | ^~~~~~~~~
p925.cpp:223:1: error: 'node_type' does not name a type
  223 | node_type extract(const key_type& x);
      | ^~~~~~~~~
p925.cpp:224:19: error: 'node_type' does not name a type
  224 | template<class K> node_type extract(K&& x);
      |                   ^~~~~~~~~
p925.cpp:225:1: error: 'insert_return_type' does not name a type
  225 | insert_return_type insert(node_type&& nh);
      | ^~~~~~~~~~~~~~~~~~
p925.cpp:226:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  226 | iterator           insert(const_iterator hint, node_type&& nh);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:226:27: error: 'const_iterator' has not been declared
  226 | iterator           insert(const_iterator hint, node_type&& nh);
      |                           ^~~~~~~~~~~~~~
p925.cpp:226:48: error: 'node_type' has not been declared
  226 | iterator           insert(const_iterator hint, node_type&& nh);
      |                                                ^~~~~~~~~
p925.cpp:226:1: error: deduced class type 'iterator' in function return type
  226 | iterator           insert(const_iterator hint, node_type&& nh);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:228:8: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  228 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |        ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:228:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  228 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                      ^
p925.cpp:228:22: note:   expected a type, got 'iterator'
p925.cpp:228:42: error: 'key_type' does not name a type; did you mean 'key_t'?
  228 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                                          ^~~~~~~~
      |                                          key_t
p925.cpp:230:8: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  230 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |        ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:230:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  230 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                      ^
p925.cpp:230:22: note:   expected a type, got 'iterator'
p925.cpp:230:36: error: 'key_type' has not been declared
  230 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                                    ^~~~~~~~
p925.cpp:232:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  232 |   iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
      |   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:232:24: error: 'const_iterator' has not been declared
  232 |   iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
      |                        ^~~~~~~~~~~~~~
p925.cpp:232:51: error: 'key_type' does not name a type; did you mean 'key_t'?
  232 |   iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
      |                                                   ^~~~~~~~
      |                                                   key_t
p925.cpp:232:3: error: deduced class type 'iterator' in function return type
  232 |   iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
      |   ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:234:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  234 |   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
      |   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:234:24: error: 'const_iterator' has not been declared
  234 |   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
      |                        ^~~~~~~~~~~~~~
p925.cpp:234:45: error: 'key_type' has not been declared
  234 |   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
      |                                             ^~~~~~~~
p925.cpp:234:3: error: deduced class type 'iterator' in function return type
  234 |   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
      |   ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:236:8: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  236 |   pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
      |        ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:236:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  236 |   pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
      |                      ^
p925.cpp:236:22: note:   expected a type, got 'iterator'
p925.cpp:236:47: error: 'key_type' does not name a type; did you mean 'key_t'?
  236 |   pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
      |                                               ^~~~~~~~
      |                                               key_t
p925.cpp:238:8: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  238 |   pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
      |        ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:238:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  238 |   pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
      |                      ^
p925.cpp:238:22: note:   expected a type, got 'iterator'
p925.cpp:238:41: error: 'key_type' has not been declared
  238 |   pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
      |                                         ^~~~~~~~
p925.cpp:240:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  240 |   iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
      |   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:240:29: error: 'const_iterator' has not been declared
  240 |   iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
      |                             ^~~~~~~~~~~~~~
p925.cpp:240:56: error: 'key_type' does not name a type; did you mean 'key_t'?
  240 |   iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
      |                                                        ^~~~~~~~
      |                                                        key_t
p925.cpp:240:3: error: deduced class type 'iterator' in function return type
  240 |   iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
      |   ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:242:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  242 |   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
      |   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:242:29: error: 'const_iterator' has not been declared
  242 |   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
      |                             ^~~~~~~~~~~~~~
p925.cpp:242:50: error: 'key_type' has not been declared
  242 |   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
      |                                                  ^~~~~~~~
p925.cpp:242:3: error: deduced class type 'iterator' in function return type
  242 |   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
      |   ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:243:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  243 | iterator  erase(iterator position);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:243:17: error: class template placeholder 'std::iterator' not permitted in this context
  243 | iterator  erase(iterator position);
      |                 ^~~~~~~~
p925.cpp:243:17: note: use 'auto' for an abbreviated function template
p925.cpp:243:1: error: deduced class type 'iterator' in function return type
  243 | iterator  erase(iterator position);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:244:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  244 | iterator  erase(const_iterator position);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:244:17: error: 'const_iterator' has not been declared
  244 | iterator  erase(const_iterator position);
      |                 ^~~~~~~~~~~~~~
p925.cpp:244:1: error: deduced class type 'iterator' in function return type
  244 | iterator  erase(const_iterator position);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:245:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  245 | size_type erase(const key_type& k);
      | ^~~~~~~~~
      | size_t
p925.cpp:246:19: error: 'size_type' does not name a type; did you mean 'size_t'?
  246 | template<class K> size_type erase(K&& x);
      |                   ^~~~~~~~~
      |                   size_t
p925.cpp:247:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  247 | 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
      |                                  ^~~~~~~~
p925.cpp:247:17: error: 'const_iterator' has not been declared
  247 | iterator  erase(const_iterator first, const_iterator last);
      |                 ^~~~~~~~~~~~~~
p925.cpp:247:39: error: 'const_iterator' has not been declared
  247 | iterator  erase(const_iterator first, const_iterator last);
      |                                       ^~~~~~~~~~~~~~
p925.cpp:247:1: error: deduced class type 'iterator' in function return type
  247 | iterator  erase(const_iterator first, const_iterator last);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:254:14: error: 'pmr::std::unordered_map' is not a template
  254 |   void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
      |              ^~~~~~~~~~~~~
p925.cpp:254:28: error: 'Key' was not declared in this scope
  254 |   void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
      |                            ^~~
p925.cpp:254:44: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  254 |   void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
      |                                            ^~~~~~~~~
      |                                            alloca
p925.cpp:256:14: error: 'pmr::std::unordered_map' is not a template
  256 |   void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
      |              ^~~~~~~~~~~~~
p925.cpp:256:28: error: 'Key' was not declared in this scope
  256 |   void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
      |                            ^~~
p925.cpp:256:44: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  256 |   void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
      |                                            ^~~~~~~~~
      |                                            alloca
p925.cpp:258:33: error: 'Key' was not declared in this scope
  258 |   void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);
      |                                 ^~~
p925.cpp:258:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  258 |   void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);
      |                                                 ^~~~~~~~~
      |                                                 alloca
p925.cpp:258:58: error: template argument 1 is invalid
  258 |   void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);
      |                                                          ^
p925.cpp:258:58: error: template argument 5 is invalid
p925.cpp:260:33: error: 'Key' was not declared in this scope
  260 |   void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);
      |                                 ^~~
p925.cpp:260:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  260 |   void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);
      |                                                 ^~~~~~~~~
      |                                                 alloca
p925.cpp:260:58: error: template argument 1 is invalid
  260 |   void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);
      |                                                          ^
p925.cpp:260:58: error: template argument 5 is invalid
p925.cpp:263:1: error: 'key_equal' does not name a type
  263 | key_equal key_eq() const;
      | ^~~~~~~~~
p925.cpp:265:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  265 | iterator
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:265:1: error: invalid use of template-name 'std::iterator' without an argument list
  265 | iterator
      | ^~~~~~~~
p925.cpp:266:1: error: expected ';' at end of member declaration
  266 | const_iterator
      | ^~~~~~~~~~~~~~
      |               ;
p925.cpp:268:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  268 |   iterator
      |   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:269:1: error: expected unqualified-id before 'template'
  269 | template<class K>
      | ^~~~~~~~
p925.cpp:271:12: error: 'key_type' does not name a type; did you mean 'key_t'?
  271 | find(const key_type& k) const;
      |            ^~~~~~~~
      |            key_t
p925.cpp:271:1: error: ISO C++ forbids declaration of 'find' with no type [-fpermissive]
  271 | find(const key_type& k) const;
      | ^~~~
p925.cpp:272:12: error: 'K' does not name a type
  272 | find(const K& k);
      |            ^
p925.cpp:272:1: error: ISO C++ forbids declaration of 'find' with no type [-fpermissive]
  272 | find(const K& k);
      | ^~~~
p925.cpp:273:3: error: 'const_iterator' does not name a type
  273 |   const_iterator find(const K& k) const;
      |   ^~~~~~~~~~~~~~
p925.cpp:275:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  275 | size_type        count(const key_type& k) const;
      | ^~~~~~~~~
      | size_t
p925.cpp:277:3: error: 'size_type' does not name a type; did you mean 'size_t'?
  277 |   size_type      count(const K& k) const;
      |   ^~~~~~~~~
      |   size_t
p925.cpp:278:33: error: 'key_type' does not name a type; did you mean 'key_t'?
  278 | bool             contains(const key_type& k) const;
      |                                 ^~~~~~~~
      |                                 key_t
p925.cpp:281:12: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  281 |       pair<iterator, iterator>
      |            ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:281:22: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  281 |       pair<iterator, iterator>
      |                      ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:281:30: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  281 |       pair<iterator, iterator>
      |                              ^
p925.cpp:281:30: note:   expected a type, got 'iterator'
p925.cpp:281:30: error: type/value mismatch at argument 2 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
p925.cpp:281:30: note:   expected a type, got 'iterator'
p925.cpp:282:12: error: invalid use of non-static data member 'pmr::std::unordered_map::const_iterator'
  282 |       pair<const_iterator, const_iterator>
      |            ^~~~~~~~~~~~~~
p925.cpp:266:1: note: declared here
  266 | const_iterator
      | ^~~~~~~~~~~~~~
p925.cpp:282:28: error: invalid use of non-static data member 'pmr::std::unordered_map::const_iterator'
  282 |       pair<const_iterator, const_iterator>
      |                            ^~~~~~~~~~~~~~
p925.cpp:266:1: note: declared here
  266 | const_iterator
      | ^~~~~~~~~~~~~~
p925.cpp:282:42: error: template argument 1 is invalid
  282 |       pair<const_iterator, const_iterator>
      |                                          ^
p925.cpp:282:42: error: template argument 2 is invalid
p925.cpp:285:69: error: 'key_type' has not been declared
  285 | mapped_type& operator[](const key_type& k); mapped_type& operator[](key_type&& k); mapped_type& at(const key_type& k);
      |                                                                     ^~~~~~~~
p925.cpp:285:106: error: 'key_type' does not name a type; did you mean 'key_t'?
  285 | ator[](const key_type& k); mapped_type& operator[](key_type&& k); mapped_type& at(const key_type& k);
      |                                                                                         ^~~~~~~~
      |                                                                                         key_t
p925.cpp:286:29: error: 'key_type' does not name a type; did you mean 'key_t'?
  286 | const mapped_type& at(const key_type& k) const;
      |                             ^~~~~~~~
      |                             key_t
p925.cpp:288:7: error: 'size_type' does not name a type; did you mean 'size_t'?
  288 |       size_type bucket_count() const noexcept;
      |       ^~~~~~~~~
      |       size_t
p925.cpp:289:7: error: 'size_type' does not name a type; did you mean 'size_t'?
  289 |       size_type max_bucket_count() const noexcept;
      |       ^~~~~~~~~
      |       size_t
p925.cpp:290:7: error: 'size_type' does not name a type; did you mean 'size_t'?
  290 |       size_type bucket_size(size_type n) const;
      |       ^~~~~~~~~
      |       size_t
p925.cpp:291:7: error: 'size_type' does not name a type; did you mean 'size_t'?
  291 |       size_type bucket(const key_type& k) const;
      |       ^~~~~~~~~
      |       size_t
p925.cpp:292:7: error: 'local_iterator' does not name a type
  292 |       local_iterator begin(size_type n);
      |       ^~~~~~~~~~~~~~
p925.cpp:293:7: error: 'const_local_iterator' does not name a type
  293 |       const_local_iterator begin(size_type n) const;
      |       ^~~~~~~~~~~~~~~~~~~~
p925.cpp:294:7: error: 'local_iterator' does not name a type
  294 |       local_iterator end(size_type n);
      |       ^~~~~~~~~~~~~~
p925.cpp:295:7: error: 'const_local_iterator' does not name a type
  295 |       const_local_iterator end(size_type n) const;
      |       ^~~~~~~~~~~~~~~~~~~~
p925.cpp:296:7: error: 'const_local_iterator' does not name a type
  296 |       const_local_iterator cbegin(size_type n) const;
      |       ^~~~~~~~~~~~~~~~~~~~
p925.cpp:297:7: error: 'const_local_iterator' does not name a type
  297 |       const_local_iterator cend(size_type n) const;
      |       ^~~~~~~~~~~~~~~~~~~~
p925.cpp:302:19: error: 'size_type' has not been declared
  302 |       void rehash(size_type n);
      |                   ^~~~~~~~~
p925.cpp:303:20: error: 'size_type' has not been declared
  303 |       void reserve(size_type n);
      |                    ^~~~~~~~~
p925.cpp:155:63: error: 'see' was not declared in this scope
  155 | unordered_map(InputIterator f, InputIterator l, size_type n = see below,
      |                                                               ^~~
p925.cpp:157:40: error: there are no arguments to 'key_equal' that depend on a template parameter, so a declaration of 'key_equal' must be available [-fpermissive]
  157 |                 const key_equal& eql = key_equal(),
      |                                        ^~~~~~~~~
p925.cpp:157:40: note: (if you use '-fpermissive', G++ will accept your code, but allowing the use of an undeclared name is deprecated)
p925.cpp:158:43: error: there are no arguments to 'allocator_type' that depend on a template parameter, so a declaration of 'allocator_type' must be available [-fpermissive]
  158 |                 const allocator_type& a = allocator_type());
      |                                           ^~~~~~~~~~~~~~
p925.cpp:168:15: error: 'see' was not declared in this scope
  168 | size_type n = see below,
      |               ^~~
p925.cpp:169:27: error: invalid use of incomplete type 'using hasher = class pmr::std::Hash' {aka 'class pmr::std::Hash'}
  169 | const hasher& hf = hasher(),
      |                           ^
p925.cpp:75:18: note: forward declaration of 'using hasher = class pmr::std::Hash' {aka 'class pmr::std::Hash'}
   75 |            class Hash = hash<Key>,
      |                  ^~~~
p925.cpp:170:24: error: 'key_equal' was not declared in this scope
  170 | const key_equal& eql = key_equal(),
      |                        ^~~~~~~~~
p925.cpp:171:27: error: 'allocator_type' was not declared in this scope
  171 | const allocator_type& a = allocator_type());
      |                           ^~~~~~~~~~~~~~
p925.cpp:195:29: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  195 |   noexcept(allocator_traits<Allocator>::is_always_equal::value &&
      |                             ^~~~~~~~~
      |                             alloca
p925.cpp:195:38: error: template argument 1 is invalid
  195 |   noexcept(allocator_traits<Allocator>::is_always_equal::value &&
      |                                      ^
p925.cpp:195:41: error: '<expression error>::is_always_equal' has not been declared
  195 |   noexcept(allocator_traits<Allocator>::is_always_equal::value &&
      |                                         ^~~~~~~~~~~~~~~
In file included from /usr/local/include/c++/12.1.0/bits/move.h:57,
                 from /usr/local/include/c++/12.1.0/bits/exception_ptr.h:43,
                 from /usr/local/include/c++/12.1.0/exception:168,
                 from /usr/local/include/c++/12.1.0/ios:39:
/usr/local/include/c++/12.1.0/type_traits: In instantiation of 'struct std::is_nothrow_move_assignable<pmr::std::Hash>':
/usr/local/include/c++/12.1.0/type_traits:3261:38:   required from 'constexpr const bool std::is_nothrow_move_assignable_v<pmr::std::Hash>'
p925.cpp:196:12:   required from here
/usr/local/include/c++/12.1.0/type_traits:1211:52: error: static assertion failed: template argument must be a complete class or an unbounded array
 1211 |       static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
      |                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/type_traits:1211:52: note: 'std::__is_complete_or_unbounded<__type_identity<pmr::std::Hash> >((std::__type_identity<pmr::std::Hash>(), std::__type_identity<pmr::std::Hash>()))' evaluates to false
p925.cpp:197:41: error: 'Pred' was not declared in this scope
  197 |            is_nothrow_move_assignable_v<Pred>);
      |                                         ^~~~
p925.cpp:197:12: error: template argument 1 is invalid
  197 |            is_nothrow_move_assignable_v<Pred>);
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp:249:29: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
  249 |   noexcept(allocator_traits<Allocator>::is_always_equal::value &&
      |                             ^~~~~~~~~
      |                             alloca
p925.cpp:249:38: error: template argument 1 is invalid
  249 |   noexcept(allocator_traits<Allocator>::is_always_equal::value &&
      |                                      ^
p925.cpp:249:41: error: '<expression error>::is_always_equal' has not been declared
  249 |   noexcept(allocator_traits<Allocator>::is_always_equal::value &&
      |                                         ^~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/type_traits: In instantiation of 'struct std::is_move_constructible<pmr::std::Hash>':
/usr/local/include/c++/12.1.0/type_traits:167:12:   required from 'struct std::__and_<std::is_move_constructible<pmr::std::Hash>, std::is_move_assignable<pmr::std::Hash> >'
/usr/local/include/c++/12.1.0/type_traits:172:12:   required from 'struct std::__and_<std::__not_<std::__is_tuple_like<pmr::std::Hash> >, std::is_move_constructible<pmr::std::Hash>, std::is_move_assignable<pmr::std::Hash> >'
/usr/local/include/c++/12.1.0/type_traits:2244:11:   required by substitution of 'template<class ... _Cond> using _Require = std::__enable_if_t<std::__and_< <template-parameter-1-1> >::value> [with _Cond = {std::__not_<std::__is_tuple_like<pmr::std::Hash> >, std::is_move_constructible<pmr::std::Hash>, std::is_move_assignable<pmr::std::Hash>}]'
/usr/local/include/c++/12.1.0/bits/move.h:196:5:   required by substitution of 'template<class _Tp> constexpr std::_Require<std::__not_<std::__is_tuple_like<_Tp> >, std::is_move_constructible<_Tp>, std::is_move_assignable<_Tp> > std::swap(_Tp&, _Tp&) [with _Tp = pmr::std::Hash]'
/usr/local/include/c++/12.1.0/type_traits:2736:24:   required by substitution of 'template<class _Tp> static std::__bool_constant<noexcept (std::swap(declval<_Tp&>(), declval<_Tp&>()))> std::__swappable_details::__do_is_nothrow_swappable_impl::__test(int) [with _Tp = pmr::std::Hash]'
/usr/local/include/c++/12.1.0/type_traits:2756:35:   required from 'struct std::__is_nothrow_swappable_impl<pmr::std::Hash>'
/usr/local/include/c++/12.1.0/type_traits:2785:12:   required from 'struct std::is_nothrow_swappable<pmr::std::Hash>'
/usr/local/include/c++/12.1.0/type_traits:2801:34:   required from 'constexpr const bool std::is_nothrow_swappable_v<pmr::std::Hash>'
p925.cpp:250:12:   required from here
/usr/local/include/c++/12.1.0/type_traits:1035:52: error: static assertion failed: template argument must be a complete class or an unbounded array
 1035 |       static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
      |                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/type_traits:1035:52: note: 'std::__is_complete_or_unbounded<__type_identity<pmr::std::Hash> >((std::__type_identity<pmr::std::Hash>(), std::__type_identity<pmr::std::Hash>()))' evaluates to false
/usr/local/include/c++/12.1.0/type_traits: In instantiation of 'struct std::is_nothrow_swappable<pmr::std::Hash>':
/usr/local/include/c++/12.1.0/type_traits:2801:34:   required from 'constexpr const bool std::is_nothrow_swappable_v<pmr::std::Hash>'
p925.cpp:250:12:   required from here
/usr/local/include/c++/12.1.0/type_traits:2788:52: error: static assertion failed: template argument must be a complete class or an unbounded array
 2788 |       static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
      |                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/type_traits:2788:52: note: 'std::__is_complete_or_unbounded<__type_identity<pmr::std::Hash> >((std::__type_identity<pmr::std::Hash>(), std::__type_identity<pmr::std::Hash>()))' evaluates to false
p925.cpp:251:35: error: 'Pred' was not declared in this scope
  251 |            is_nothrow_swappable_v<Pred>);
      |                                   ^~~~
p925.cpp:251:12: error: template argument 1 is invalid
  251 |            is_nothrow_swappable_v<Pred>);
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp: In constructor 'pmr::std::unordered_map::unordered_map(InputIterator, InputIterator, int, const int&)':
p925.cpp:178:40: error: there are no arguments to 'key_equal' that depend on a template parameter, so a declaration of 'key_equal' must be available [-fpermissive]
  178 |     : unordered_map(f, l, n, hasher(), key_equal(), a) { }
      |                                        ^~~~~~~~~
p925.cpp: In constructor 'pmr::std::unordered_map::unordered_map(InputIterator, InputIterator, int, const hasher&, const int&)':
p925.cpp:182:30: error: there are no arguments to 'key_equal' that depend on a template parameter, so a declaration of 'key_equal' must be available [-fpermissive]
  182 | : unordered_map(f, l, n, hf, key_equal(), a) { } template<container-compatible-range<value_type> R>
      |                              ^~~~~~~~~
p925.cpp: In constructor 'pmr::std::unordered_map::unordered_map(int, int, const int&)':
p925.cpp:189:33: error: invalid use of incomplete type 'using hasher = class pmr::std::Hash' {aka 'class pmr::std::Hash'}
  189 |   : unordered_map(il, n, hasher(), key_equal(), a) { }
      |                                 ^
p925.cpp:75:18: note: forward declaration of 'using hasher = class pmr::std::Hash' {aka 'class pmr::std::Hash'}
   75 |            class Hash = hash<Key>,
      |                  ^~~~
p925.cpp:189:36: error: 'key_equal' was not declared in this scope
  189 |   : unordered_map(il, n, hasher(), key_equal(), a) { }
      |                                    ^~~~~~~~~
p925.cpp: In constructor 'pmr::std::unordered_map::unordered_map(int, int, const hasher&, const int&)':
p925.cpp:192:30: error: 'key_equal' was not declared in this scope
  192 |   : unordered_map(il, n, hf, key_equal(), a) { }
      |                              ^~~~~~~~~
p925.cpp: At global scope:
p925.cpp:306:19: error: 'iter_key_type' was not declared in this scope
  306 | class Hash = hash<iter_key_type<InputIterator>>,
      |                   ^~~~~~~~~~~~~
p925.cpp:306:46: error: template argument 1 is invalid
  306 | class Hash = hash<iter_key_type<InputIterator>>,
      |                                              ^~
p925.cpp:307:23: error: 'iter_key_type' was not declared in this scope
  307 | class Pred = equal_to<iter_key_type<InputIterator>>,
      |                       ^~~~~~~~~~~~~
p925.cpp:307:50: error: template argument 1 is invalid
  307 | class Pred = equal_to<iter_key_type<InputIterator>>,
      |                                                  ^~
p925.cpp:308:29: error: 'iter_to_alloc_type' was not declared in this scope
  308 | class Allocator = allocator<iter_to_alloc_type<InputIterator>>>
      |                             ^~~~~~~~~~~~~~~~~~
p925.cpp:308:61: error: template argument 1 is invalid
  308 | class Allocator = allocator<iter_to_alloc_type<InputIterator>>>
      |                                                             ^~
p925.cpp:309:54: error: 'see_below' has not been declared
  309 | unordered_map(InputIterator, InputIterator, typename see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      |                                                      ^~~~~~~~~
p925.cpp:309:77: error: 'see_below' was not declared in this scope
  309 | unordered_map(InputIterator, InputIterator, typename see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      |                                                                             ^~~~~~~~~
p925.cpp:310:4: error: 'pmr::std::unordered_map' is not a template
  310 | -> unordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash, Pred, Allocator>;
      |    ^~~~~~~~~~~~~
p925.cpp:310:18: error: 'iter_key_type' was not declared in this scope
  310 | -> unordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash, Pred, Allocator>;
      |                  ^~~~~~~~~~~~~
p925.cpp:310:45: error: expected primary-expression before '>' token
  310 | -> unordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash, Pred, Allocator>;
      |                                             ^
p925.cpp:310:46: error: expected constructor, destructor, or type conversion before ',' token
  310 | -> unordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash, Pred, Allocator>;
      |                                              ^
p925.cpp:311:51: error: 'range_key_type' was not declared in this scope
  311 | template<ranges::input_range R, class Hash = hash<range_key_type<R>>, class Pred = equal_to<range-key-type<R>>,
      |                                                   ^~~~~~~~~~~~~~
p925.cpp:311:67: error: template argument 1 is invalid
  311 | template<ranges::input_range R, class Hash = hash<range_key_type<R>>, class Pred = equal_to<range-key-type<R>>,
      |                                                                   ^~
p925.cpp:311:93: error: 'range' was not declared in this scope; did you mean 'std::ranges::range'?
  311 | late<ranges::input_range R, class Hash = hash<range_key_type<R>>, class Pred = equal_to<range-key-type<R>>,
      |                                                                                         ^~~~~
      |                                                                                         std::ranges::range
In file included from /usr/local/include/c++/12.1.0/string_view:50,
                 from /usr/local/include/c++/12.1.0/bits/basic_string.h:48,
                 from /usr/local/include/c++/12.1.0/string:53:
/usr/local/include/c++/12.1.0/bits/ranges_base.h:583:13: note: 'std::ranges::range' declared here
  583 |     concept range = requires(_Tp& __t)
      |             ^~~~~
p925.cpp:311:99: error: 'key' was not declared in this scope; did you mean 'key_t'?
  311 | anges::input_range R, class Hash = hash<range_key_type<R>>, class Pred = equal_to<range-key-type<R>>,
      |                                                                                         ^~~
      |                                                                                         key_t
p925.cpp:311:103: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  311 | ges::input_range R, class Hash = hash<range_key_type<R>>, class Pred = equal_to<range-key-type<R>>,
      |                                                                                           ^~~~
      |                                                                                           std::__cmp_cat::type
In file included from /usr/local/include/c++/12.1.0/bits/char_traits.h:45:
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:311:109: error: template argument 1 is invalid
  311 | ges::input_range R, class Hash = hash<range_key_type<R>>, class Pred = equal_to<range-key-type<R>>,
      |                                                                                                 ^~

p925.cpp:312:29: error: 'range_to_alloc_type' was not declared in this scope
  312 | class Allocator = allocator<range_to_alloc_type<R>>>
      |                             ^~~~~~~~~~~~~~~~~~~
p925.cpp:312:50: error: template argument 1 is invalid
  312 | class Allocator = allocator<range_to_alloc_type<R>>>
      |                                                  ^~
p925.cpp:313:27: error: expected ')' before ',' token
  313 | unordered_map(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      |              ~            ^
      |                           )
p925.cpp:315:56: error: 'key_type' does not name a type; did you mean 'key_t'?
  315 |                                      equal_range(const key_type& k);
      |                                                        ^~~~~~~~
      |                                                        key_t
p925.cpp:315:68: error: expected constructor, destructor, or type conversion before ';' token
  315 |                                      equal_range(const key_type& k);
      |                                                                    ^
p925.cpp:316:56: error: 'key_type' does not name a type; did you mean 'key_t'?
  316 |                                      equal_range(const key_type& k) const;
      |                                                        ^~~~~~~~
      |                                                        key_t
p925.cpp:316:74: error: expected constructor, destructor, or type conversion before ';' token
  316 |                                      equal_range(const key_type& k) const;
      |                                                                          ^
p925.cpp:317:56: error: 'K' does not name a type
  317 |                                      equal_range(const K& k);
      |                                                        ^
p925.cpp:317:61: error: expected constructor, destructor, or type conversion before ';' token
  317 |                                      equal_range(const K& k);
      |                                                             ^
p925.cpp:318:6: error: 'const_iterator' was not declared in this scope
  318 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |      ^~~~~~~~~~~~~~
p925.cpp:318:22: error: 'const_iterator' was not declared in this scope
  318 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                      ^~~~~~~~~~~~~~
p925.cpp:318:36: error: template argument 1 is invalid
  318 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                    ^
p925.cpp:318:36: error: template argument 2 is invalid
p925.cpp:318:56: error: 'K' does not name a type
  318 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                                        ^
p925.cpp:318:62: error: non-member function 'int pmr::std::equal_range(const int&)' cannot have cv-qualifier
  318 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                                              ^~~~~
p925.cpp:319:8: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  319 |   pair<iterator, iterator>
      |        ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:319:18: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  319 |   pair<iterator, iterator>
      |                  ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:319:26: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  319 |   pair<iterator, iterator>
      |                          ^
p925.cpp:319:26: note:   expected a type, got 'iterator'
p925.cpp:319:26: error: type/value mismatch at argument 2 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
p925.cpp:319:26: note:   expected a type, got 'iterator'
p925.cpp:320:1: error: expected unqualified-id before 'template'
  320 | template<class K>
      | ^~~~~~~~
p925.cpp:327:54: error: 'see_below' has not been declared
  327 | unordered_map(InputIterator, InputIterator, typename see_below::size_type, Allocator)
      |                                                      ^~~~~~~~~
p925.cpp:328:4: error: 'pmr::std::unordered_map' is not a template
  328 | -> unordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |    ^~~~~~~~~~~~~
p925.cpp:328:18: error: 'iter_key_type' was not declared in this scope
  328 | -> unordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                  ^~~~~~~~~~~~~
p925.cpp:328:45: error: expected primary-expression before '>' token
  328 | -> unordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                                             ^
p925.cpp:328:46: error: expected constructor, destructor, or type conversion before ',' token
  328 | -> unordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                                              ^
p925.cpp:332:4: error: 'pmr::std::unordered_map' is not a template
  332 | -> unordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |    ^~~~~~~~~~~~~
p925.cpp:332:18: error: 'iter_key_type' was not declared in this scope
  332 | -> unordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                  ^~~~~~~~~~~~~
p925.cpp:332:45: error: expected primary-expression before '>' token
  332 | -> unordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                                             ^
p925.cpp:332:46: error: expected constructor, destructor, or type conversion before ',' token
  332 | -> unordered_map<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                                              ^
p925.cpp:335:54: error: 'see_below' has not been declared
  335 | unordered_map(InputIterator, InputIterator, typename see_below::size_type, Hash, Allocator)
      |                                                      ^~~~~~~~~
p925.cpp:336:4: error: 'pmr::std::unordered_map' is not a template
  336 | -> unordered_map<iter-key-type<InputIterator>, iter_mapped_type<InputIterator>, Hash, equal_to<iter_key_type<InputIterator>>, Allocator>;
      |    ^~~~~~~~~~~~~
p925.cpp:336:18: error: 'iter' was not declared in this scope
  336 | -> unordered_map<iter-key-type<InputIterator>, iter_mapped_type<InputIterator>, Hash, equal_to<iter_key_type<InputIterator>>, Allocator>;
      |                  ^~~~
p925.cpp:336:23: error: 'key' was not declared in this scope; did you mean 'key_t'?
  336 | -> unordered_map<iter-key-type<InputIterator>, iter_mapped_type<InputIterator>, Hash, equal_to<iter_key_type<InputIterator>>, Allocator>;
      |                       ^~~
      |                       key_t
p925.cpp:336:27: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  336 | -> unordered_map<iter-key-type<InputIterator>, iter_mapped_type<InputIterator>, Hash, equal_to<iter_key_type<InputIterator>>, Allocator>;
      |                           ^~~~
      |                           std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:336:45: error: expected primary-expression before '>' token
  336 | -> unordered_map<iter-key-type<InputIterator>, iter_mapped_type<InputIterator>, Hash, equal_to<iter_key_type<InputIterator>>, Allocator>;
      |                                             ^
p925.cpp:336:46: error: expected constructor, destructor, or type conversion before ',' token
  336 | -> unordered_map<iter-key-type<InputIterator>, iter_mapped_type<InputIterator>, Hash, equal_to<iter_key_type<InputIterator>>, Allocator>;
      |                                              ^
p925.cpp:337:10: error: 'std::ranges::tcode' has not been declared
  337 | template<ranges::\tcode{input_range} R, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Allocator)
      |          ^~~~~~
p925.cpp:337:24: error: expected '>' before '{' token
  337 | template<ranges::\tcode{input_range} R, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Allocator)
      |                        ^
p925.cpp:337:24: error: expected unqualified-id before '{' token
p925.cpp:337:38: error: 'R' does not name a type
  337 | template<ranges::\tcode{input_range} R, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Allocator)
      |                                      ^
p925.cpp:340:36: error: expected ')' before ',' token
  340 |          unordered_map(from_range_t, R&&, Allocator)
      |                       ~            ^
      |                                    )
p925.cpp:342:88: error: expected ')' before ',' token
  342 | template<ranges::input_range R, class Hash, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
      |                                                                           ~            ^
      |                                                                                        )
p925.cpp:344:102: error: expected nested-name-specifier before 'see'
  344 | s Key, class T, class Allocator> unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type,
      |                                                                                         ^~~

p925.cpp:344:106: error: expected ',' or '...' before 'below'
  344 | y, class T, class Allocator> unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type,
      |                                                                                         ^~~~~

p925.cpp:346:15: error: 'pmr::std::unordered_map' is not a template
  346 |            -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
      |               ^~~~~~~~~~~~~
p925.cpp:346:73: error: expected constructor, destructor, or type conversion before ';' token
  346 |            -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
      |                                                                         ^
p925.cpp:349:15: error: 'pmr::std::unordered_map' is not a template
  349 |            -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
      |               ^~~~~~~~~~~~~
p925.cpp:349:73: error: expected constructor, destructor, or type conversion before ';' token
  349 |            -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
      |                                                                         ^
p925.cpp:350:114: error: 'see_below' has not been declared
  350 |  T, class Hash, class Allocator> unordered_map(initializer_list<pair<Key, T>>, typename see_below::size_type, Hash, Allocator)
      |                                                                                         ^~~~~~~~~

p925.cpp:351:15: error: 'pmr::std::unordered_map' is not a template
  351 |            -> unordered_map<Key, T, Hash, equal_to<Key>, Allocator>;
      |               ^~~~~~~~~~~~~
p925.cpp:351:68: error: expected constructor, destructor, or type conversion before ';' token
  351 |            -> unordered_map<Key, T, Hash, equal_to<Key>, Allocator>;
      |                                                                    ^
p925.cpp:355:1: error: deduction guide for 'std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>' must have trailing return type
  355 | unordered_map() : unordered_map(size_type(see below)) { } explicit unordered_map(size_type n,
      | ^~~~~~~~~~~~~
In file included from /usr/local/include/c++/12.1.0/unordered_map:47,
                 from N4910.h:12:
/usr/local/include/c++/12.1.0/bits/unordered_map.h:102:11: note: 'template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> class std::unordered_map' declared here
  102 |     class unordered_map
      |           ^~~~~~~~~~~~~
p925.cpp:355:91: error: expected ')' before 'n'
  355 | unordered_map() : unordered_map(size_type(see below)) { } explicit unordered_map(size_type n,
      |                                                                                 ~         ^~
      |                                                                                           )
p925.cpp:361:16: error: 'hasher' does not name a type
  361 |          const hasher& hf = hasher(),
      |                ^~~~~~
p925.cpp:368:1: error: 'size_type' has not been declared
  368 | size_type n = see_below,
      | ^~~~~~~~~
p925.cpp:368:15: error: 'see_below' was not declared in this scope
  368 | size_type n = see_below,
      |               ^~~~~~~~~
p925.cpp:369:7: error: 'hasher' does not name a type
  369 | const hasher& hf = hasher(),
      |       ^~~~~~
p925.cpp:369:20: error: there are no arguments to 'hasher' that depend on a template parameter, so a declaration of 'hasher' must be available [-fpermissive]
  369 | const hasher& hf = hasher(),
      |                    ^~~~~~
p925.cpp:370:7: error: 'key_equal' does not name a type
  370 | const key_equal& eql = key_equal(),
      |       ^~~~~~~~~
p925.cpp:370:24: error: there are no arguments to 'key_equal' that depend on a template parameter, so a declaration of 'key_equal' must be available [-fpermissive]
  370 | const key_equal& eql = key_equal(),
      |                        ^~~~~~~~~
p925.cpp:371:7: error: 'allocator_type' does not name a type
  371 | const allocator_type& a = allocator_type());
      |       ^~~~~~~~~~~~~~
p925.cpp:371:27: error: there are no arguments to 'allocator_type' that depend on a template parameter, so a declaration of 'allocator_type' must be available [-fpermissive]
  371 | const allocator_type& a = allocator_type());
      |                           ^~~~~~~~~~~~~~
p925.cpp:367:3: error: deduction guide for 'std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>' must have trailing return type
  367 |   unordered_map(InputIterator f, InputIterator l,
      |   ^~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/unordered_map.h:102:11: note: 'template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> class std::unordered_map' declared here
  102 |     class unordered_map
      |           ^~~~~~~~~~~~~
p925.cpp:372:10: error: 'container' has not been declared
  372 | template<container-compatible-range<value_type> R> unordered_map(from_range_t, R&& rg,
      |          ^~~~~~~~~
p925.cpp:372:19: error: expected '>' before '-' token
  372 | template<container-compatible-range<value_type> R> unordered_map(from_range_t, R&& rg,
      |                   ^
p925.cpp:372:78: error: expected ')' before ',' token
  372 | template<container-compatible-range<value_type> R> unordered_map(from_range_t, R&& rg,
      |                                                                 ~            ^
      |                                                                              )
p925.cpp:377:32: error: 'value_type' was not declared in this scope
  377 | unordered_map(initializer_list<value_type> il, size_type n = see below,
      |                                ^~~~~~~~~~
p925.cpp:377:42: error: template argument 1 is invalid
  377 | unordered_map(initializer_list<value_type> il, size_type n = see below,
      |                                          ^
p925.cpp:377:48: error: 'size_type' has not been declared
  377 | unordered_map(initializer_list<value_type> il, size_type n = see below,
      |                                                ^~~~~~~~~
p925.cpp:377:62: error: 'see' was not declared in this scope
  377 | unordered_map(initializer_list<value_type> il, size_type n = see below,
      |                                                              ^~~
p925.cpp:377:66: error: expected ',' or '...' before 'below'
  377 | unordered_map(initializer_list<value_type> il, size_type n = see below,
      |                                                                  ^~~~~
p925.cpp:379:43: error: expected ')' before ';' token
  379 | mapped_type& operator[](const key_type& k);
      |                                           ^
      |                                           )
p925.cpp:377:14: note: to match this '('
  377 | unordered_map(initializer_list<value_type> il, size_type n = see below,
      |              ^
p925.cpp:377:1: error: deduction guide for 'std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>' must have trailing return type
  377 | unordered_map(initializer_list<value_type> il, size_type n = see below,
      | ^~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/unordered_map.h:102:11: note: 'template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> class std::unordered_map' declared here
  102 |     class unordered_map
      |           ^~~~~~~~~~~~~
p925.cpp:382:7: error: 'mapped_type' does not name a type
  382 | const mapped_type& at(const key_type& k) const;
      |       ^~~~~~~~~~~
p925.cpp:386:8: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  386 |   pair<iterator, bool> insert(P&& obj);
      |        ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:386:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  386 |   pair<iterator, bool> insert(P&& obj);
      |                      ^
p925.cpp:386:22: note:   expected a type, got 'iterator'
p925.cpp:389:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  389 |   iterator insert(const_iterator hint, P&& obj);
      |   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:389:19: error: 'template<class P> iterator<...auto...> pmr::insert' conflicts with a previous declaration
  389 |   iterator insert(const_iterator hint, P&& obj);
      |                   ^~~~~~~~~~~~~~
p925.cpp:386:24: note: previous declaration 'int pmr::insert(P&&)'
  386 |   pair<iterator, bool> insert(P&& obj);
      |                        ^~~~~~
p925.cpp:389:19: error: 'const_iterator' was not declared in this scope
  389 |   iterator insert(const_iterator hint, P&& obj);
      |                   ^~~~~~~~~~~~~~
p925.cpp:389:41: error: expected primary-expression before '&&' token
  389 |   iterator insert(const_iterator hint, P&& obj);
      |                                         ^~
p925.cpp:389:44: error: 'obj' was not declared in this scope
  389 |   iterator insert(const_iterator hint, P&& obj);
      |                                            ^~~
p925.cpp:393:8: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  393 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |        ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:393:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  393 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                      ^
p925.cpp:393:22: note:   expected a type, got 'iterator'
p925.cpp:393:42: error: 'key_type' does not name a type; did you mean 'key_t'?
  393 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                                          ^~~~~~~~
      |                                          key_t
p925.cpp:395:6: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  395 |      iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
      |      ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:395:27: error: 'template<class ... Args> iterator<...auto...> pmr::try_emplace' conflicts with a previous declaration
  395 |      iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
      |                           ^~~~~~~~~~~~~~
p925.cpp:393:24: note: previous declaration 'int pmr::try_emplace(const int&, Args&& ...)'
  393 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                        ^~~~~~~~~~~
p925.cpp:395:27: error: 'const_iterator' was not declared in this scope
  395 |      iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
      |                           ^~~~~~~~~~~~~~
p925.cpp:395:48: error: expected primary-expression before 'const'
  395 |      iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
      |                                                ^~~~~
p925.cpp:395:71: error: expected primary-expression before '&&' token
  395 |      iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
      |                                                                       ^~
p925.cpp:401:8: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  401 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |        ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:401:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  401 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                      ^
p925.cpp:401:22: note:   expected a type, got 'iterator'
p925.cpp:401:36: error: 'template<class ... Args> int pmr::try_emplace' conflicts with a previous declaration
  401 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                                    ^~~~~~~~
p925.cpp:393:24: note: previous declaration 'int pmr::try_emplace(const int&, Args&& ...)'
  393 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                        ^~~~~~~~~~~
p925.cpp:401:36: error: 'key_type' was not declared in this scope; did you mean 'key_t'?
  401 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                                    ^~~~~~~~
      |                                    key_t
p925.cpp:401:47: error: 'k' was not declared in this scope
  401 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                                               ^
p925.cpp:401:54: error: expected primary-expression before '&&' token
  401 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                                                      ^~
p925.cpp:401:64: error: expression list treated as compound expression in initializer [-fpermissive]
  401 |   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
      |                                                                ^
p925.cpp:403:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  403 |   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
      |   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:403:24: error: 'template<class ... Args> iterator<...auto...> pmr::try_emplace' conflicts with a previous declaration
  403 |   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
      |                        ^~~~~~~~~~~~~~
p925.cpp:393:24: note: previous declaration 'int pmr::try_emplace(const int&, Args&& ...)'
  393 |   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
      |                        ^~~~~~~~~~~
p925.cpp:403:24: error: 'const_iterator' was not declared in this scope
  403 |   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
      |                        ^~~~~~~~~~~~~~
p925.cpp:403:45: error: 'key_type' was not declared in this scope; did you mean 'key_t'?
  403 |   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
      |                                             ^~~~~~~~
      |                                             key_t
p925.cpp:403:56: error: 'k' was not declared in this scope
  403 |   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
      |                                                        ^
p925.cpp:403:63: error: expected primary-expression before '&&' token
  403 |   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
      |                                                               ^~
p925.cpp:409:8: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  409 |   pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
      |        ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:409:22: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  409 |   pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
      |                      ^
p925.cpp:409:22: note:   expected a type, got 'iterator'
p925.cpp:409:47: error: 'key_type' does not name a type; did you mean 'key_t'?
  409 |   pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
      |                                               ^~~~~~~~
      |                                               key_t
p925.cpp:411:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  411 |   iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
      |   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:411:29: error: 'template<class M> iterator<...auto...> pmr::insert_or_assign' conflicts with a previous declaration
  411 |   iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
      |                             ^~~~~~~~~~~~~~
p925.cpp:409:24: note: previous declaration 'int pmr::insert_or_assign(const int&, M&&)'
  409 |   pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
      |                        ^~~~~~~~~~~~~~~~
p925.cpp:411:29: error: 'const_iterator' was not declared in this scope
  411 |   iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
      |                             ^~~~~~~~~~~~~~
p925.cpp:411:50: error: expected primary-expression before 'const'
  411 |   iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
      |                                                  ^~~~~
p925.cpp:411:70: error: expected primary-expression before '&&' token
  411 |   iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
      |                                                                      ^~
p925.cpp:411:73: error: 'obj' was not declared in this scope
  411 |   iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
      |                                                                         ^~~
p925.cpp:414:6: error: 'M' was not declared in this scope
  414 | ward<M>(obj).
      |      ^
p925.cpp:414:1: error: specializing member '::ward<<expression error> >' requires 'template<>' syntax
  414 | ward<M>(obj).
      | ^~~~~~~
p925.cpp:421:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  421 |   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
      |   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:421:29: error: 'template<class M> iterator<...auto...> pmr::insert_or_assign' conflicts with a previous declaration
  421 |   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
      |                             ^~~~~~~~~~~~~~
p925.cpp:409:24: note: previous declaration 'int pmr::insert_or_assign(const int&, M&&)'
  409 |   pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
      |                        ^~~~~~~~~~~~~~~~
p925.cpp:421:29: error: 'const_iterator' was not declared in this scope
  421 |   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
      |                             ^~~~~~~~~~~~~~
p925.cpp:421:50: error: 'key_type' was not declared in this scope; did you mean 'key_t'?
  421 |   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
      |                                                  ^~~~~~~~
      |                                                  key_t
p925.cpp:421:61: error: 'k' was not declared in this scope
  421 |   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
      |                                                             ^
p925.cpp:421:65: error: expected primary-expression before '&&' token
  421 |   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
      |                                                                 ^~
p925.cpp:421:68: error: 'obj' was not declared in this scope
  421 |   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
      |                                                                    ^~~
p925.cpp:424:6: error: 'forward' in namespace 'pmr::std' does not name a template type
  424 | std::forward<M>(obj).
      |      ^~~~~~~
p925.cpp:433:29: error: 'c' was not declared in this scope
  433 |        auto original_size = c.size();
      |                             ^
p925.cpp:434:8: error: expected unqualified-id before 'for'
  434 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |        ^~~
p925.cpp:434:49: error: 'i' does not name a type
  434 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                                 ^
p925.cpp:434:60: error: expected unqualified-id before ')' token
  434 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                                            ^
p925.cpp:439:8: error: expected unqualified-id before 'return'
  439 |        return original_size - c.size();
      |        ^~~~~~
p925.cpp:464:21: error: 'implementation_defined' does not name a type
  464 |   using size_type = implementation_defined ; // see 24.2
      |                     ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:465:27: error: 'implementation_defined' does not name a type
  465 |   using difference_type = implementation_defined ; // see 24.2
      |                           ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:466:20: error: 'implementation_defined' does not name a type
  466 |   using iterator = implementation_defined ; // see 24.2
      |                    ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:467:26: error: 'implementation_defined' does not name a type
  467 |   using const_iterator = implementation_defined ; // see 24.2
      |                          ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:468:26: error: 'implementation_defined' does not name a type
  468 |   using local_iterator = implementation_defined ; // see 24.2
      |                          ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:469:32: error: 'implementation_defined' does not name a type
  469 |   using const_local_iterator = implementation_defined ; // see 24.2
      |                                ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:470:22: error: 'unspecified' does not name a type
  470 |   using node_type  = unspecified;
      |                      ^~~~~~~~~~~
p925.cpp:472:40: error: expected ')' before 'n'
  472 |   explicit unordered_multimap(size_type n,
      |                              ~         ^~
      |                                        )
p925.cpp:477:54: error: 'size_type' has not been declared
  477 | unordered_multimap(InputIterator f, InputIterator l, size_type n = see_below,
      |                                                      ^~~~~~~~~
p925.cpp:481:10: error: 'container' has not been declared
  481 | template<container-compatible-range<value_type> R> unordered_multimap(from_range_t, R&& rg,
      |          ^~~~~~~~~
p925.cpp:481:19: error: expected '>' before '-' token
  481 | template<container-compatible-range<value_type> R> unordered_multimap(from_range_t, R&& rg,
      |                   ^
p925.cpp:481:83: error: expected ')' before ',' token
  481 | template<container-compatible-range<value_type> R> unordered_multimap(from_range_t, R&& rg,
      |                                                                      ~            ^
      |                                                                                   )
p925.cpp:492:1: error: 'size_type' has not been declared
  492 | size_type n = see_below,
      | ^~~~~~~~~
p925.cpp:496:31: error: expected ')' before 'n'
  496 |   unordered_multimap(size_type n, const allocator_type& a)
      |                     ~         ^~
      |                               )
p925.cpp:498:31: error: expected ')' before 'n'
  498 |   unordered_multimap(size_type n, const hasher& hf, const allocator_type& a)
      |                     ~         ^~
      |                               )
p925.cpp:501:58: error: 'size_type' has not been declared
  501 |     unordered_multimap(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
      |                                                          ^~~~~~~~~
p925.cpp:504:58: error: 'size_type' has not been declared
  504 |     unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf,
      |                                                          ^~~~~~~~~
p925.cpp:506:64: error: 'container_compatible_range' has not been declared
  506 | : unordered_multimap(f, l, n, hf, key_equal(), a) { } template<container_compatible_range<value_type> R>
      |                                                                ^~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp:506:90: error: expected '>' before '<' token
  506 |  unordered_multimap(f, l, n, hf, key_equal(), a) { } template<container_compatible_range<value_type> R>
      |                                                                                         ^

p925.cpp:507:34: error: expected ')' before ',' token
  507 |   unordered_multimap(from_range_t, R&& rg, size_type n, const allocator_type& a)
      |                     ~            ^
      |                                  )
p925.cpp:509:43: error: 'container_compatible_range' has not been declared
  509 | n, hasher(), key_equal(), a) { } template<container_compatible_range<value_type> R>
      |                                           ^~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp:509:69: error: expected '>' before '<' token
  509 | n, hasher(), key_equal(), a) { } template<container_compatible_range<value_type> R>
      |                                                                     ^
p925.cpp:510:34: error: expected ')' before ',' token
  510 |   unordered_multimap(from_range_t, R&& rg, size_type n, const hasher& hf,
      |                     ~            ^
      |                                  )
p925.cpp:513:55: error: 'size_type' has not been declared
  513 |   unordered_multimap(initializer_list<value_type> il, size_type n, const allocator_type& a)
      |                                                       ^~~~~~~~~
p925.cpp:515:55: error: 'size_type' has not been declared
  515 |   unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf,
      |                                                       ^~~~~~~~~
p925.cpp:526:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  526 |   iterator       begin() noexcept;
      |   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:526:3: error: deduced class type 'iterator' in function return type
  526 |   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
      |                                  ^~~~~~~~
p925.cpp:527:3: error: 'const_iterator' does not name a type
  527 |   const_iterator begin() const noexcept;
      |   ^~~~~~~~~~~~~~
p925.cpp:528:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  528 |   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
      |                                  ^~~~~~~~
p925.cpp:528:3: error: deduced class type 'iterator' in function return type
  528 |   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
      |                                  ^~~~~~~~
p925.cpp:529:3: error: 'const_iterator' does not name a type
  529 |   const_iterator end() const noexcept;
      |   ^~~~~~~~~~~~~~
p925.cpp:530:1: error: 'const_iterator' does not name a type
  530 | const_iterator cbegin() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:531:1: error: 'const_iterator' does not name a type
  531 | const_iterator cend() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:534:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  534 | size_type size() const noexcept;
      | ^~~~~~~~~
      | size_t
p925.cpp:535:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  535 | size_type max_size() const noexcept;
      | ^~~~~~~~~
      | size_t
p925.cpp:537:25: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  537 | template<class... Args> iterator emplace(Args&&... args);
      |                         ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:537:25: error: deduced class type 'iterator' in function return type
  537 | template<class... Args> iterator emplace(Args&&... args);
      |                         ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:538:25: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  538 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj);
      |                         ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:538:47: error: 'const_iterator' has not been declared
  538 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj);
      |                                               ^~~~~~~~~~~~~~
p925.cpp:538:25: error: deduced class type 'iterator' in function return type
  538 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj);
      |                         ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:538:89: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  538 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj);
      |                                                                                         ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:538:89: error: deduced class type 'iterator' in function return type
  538 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj);
      |                                                                                         ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:539:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  539 | iterator insert(value_type&& obj);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:539:1: error: deduced class type 'iterator' in function return type
  539 | iterator insert(value_type&& obj);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:540:19: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  540 | template<class P> iterator insert(P&& obj);
      |                   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:540:19: error: deduced class type 'iterator' in function return type
  540 | template<class P> iterator insert(P&& obj);
      |                   ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:541:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  541 | iterator insert(const_iterator hint, const value_type& obj);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:541:17: error: 'const_iterator' has not been declared
  541 | iterator insert(const_iterator hint, const value_type& obj);
      |                 ^~~~~~~~~~~~~~
p925.cpp:541:1: error: deduced class type 'iterator' in function return type
  541 | iterator insert(const_iterator hint, const value_type& obj);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:542:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  542 | iterator insert(const_iterator hint, value_type&& obj);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:542:17: error: 'const_iterator' has not been declared
  542 | iterator insert(const_iterator hint, value_type&& obj);
      |                 ^~~~~~~~~~~~~~
p925.cpp:542:1: error: deduced class type 'iterator' in function return type
  542 | iterator insert(const_iterator hint, value_type&& obj);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:543:19: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  543 | template<class P> iterator insert(const_iterator hint, P&& obj);
      |                   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:543:35: error: 'const_iterator' has not been declared
  543 | template<class P> iterator insert(const_iterator hint, P&& obj);
      |                                   ^~~~~~~~~~~~~~
p925.cpp:543:19: error: deduced class type 'iterator' in function return type
  543 | template<class P> iterator insert(const_iterator hint, P&& obj);
      |                   ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:544:94: error: 'container' has not been declared
  544 | ate<class InputIterator> void insert(InputIterator first, InputIterator last); template<container-compatible-range<value_type> R>
      |                                                                                         ^~~~~~~~~

p925.cpp:544:103: error: expected '>' before '-' token
  544 |  InputIterator> void insert(InputIterator first, InputIterator last); template<container-compatible-range<value_type> R>
      |                                                                                         ^

p925.cpp:545:21: error: 'R' has not been declared
  545 |   void insert_range(R&& rg);
      |                     ^
p925.cpp:547:1: error: 'node_type' does not name a type
  547 | node_type extract(const_iterator position);
      | ^~~~~~~~~
p925.cpp:548:1: error: 'node_type' does not name a type
  548 | node_type extract(const key_type& x);
      | ^~~~~~~~~
p925.cpp:549:19: error: 'node_type' does not name a type
  549 | template<class K> node_type extract(K&& x);
      |                   ^~~~~~~~~
p925.cpp:550:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  550 | iterator insert(node_type&& nh);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:550:17: error: 'node_type' has not been declared
  550 | iterator insert(node_type&& nh);
      |                 ^~~~~~~~~
p925.cpp:550:1: error: deduced class type 'iterator' in function return type
  550 | iterator insert(node_type&& nh);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:551:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  551 | iterator insert(const_iterator hint, node_type&& nh);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:551:17: error: 'const_iterator' has not been declared
  551 | iterator insert(const_iterator hint, node_type&& nh);
      |                 ^~~~~~~~~~~~~~
p925.cpp:551:38: error: 'node_type' has not been declared
  551 | iterator insert(const_iterator hint, node_type&& nh);
      |                                      ^~~~~~~~~
p925.cpp:551:1: error: deduced class type 'iterator' in function return type
  551 | iterator insert(const_iterator hint, node_type&& nh);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:552:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  552 | iterator  erase(iterator position);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:552:17: error: class template placeholder 'std::iterator' not permitted in this context
  552 | iterator  erase(iterator position);
      |                 ^~~~~~~~
p925.cpp:552:17: note: use 'auto' for an abbreviated function template
p925.cpp:552:1: error: deduced class type 'iterator' in function return type
  552 | iterator  erase(iterator position);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:553:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  553 | iterator  erase(const_iterator position);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:553:17: error: 'const_iterator' has not been declared
  553 | iterator  erase(const_iterator position);
      |                 ^~~~~~~~~~~~~~
p925.cpp:553:1: error: deduced class type 'iterator' in function return type
  553 | iterator  erase(const_iterator position);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:554:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  554 | size_type erase(const key_type& k);
      | ^~~~~~~~~
      | size_t
p925.cpp:555:19: error: 'size_type' does not name a type; did you mean 'size_t'?
  555 | template<class K> size_type erase(K&& x);
      |                   ^~~~~~~~~
      |                   size_t
p925.cpp:556:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  556 | 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
      |                                  ^~~~~~~~
p925.cpp:556:17: error: 'const_iterator' has not been declared
  556 | iterator  erase(const_iterator first, const_iterator last);
      |                 ^~~~~~~~~~~~~~
p925.cpp:556:39: error: 'const_iterator' has not been declared
  556 | iterator  erase(const_iterator first, const_iterator last);
      |                                       ^~~~~~~~~~~~~~
p925.cpp:556:1: error: deduced class type 'iterator' in function return type
  556 | iterator  erase(const_iterator first, const_iterator last);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:567:14: error: 'pmr::std::unordered_map' is not a template
  567 |   void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
      |              ^~~~~~~~~~~~~
p925.cpp:569:14: error: 'pmr::std::unordered_map' is not a template
  569 |   void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
      |              ^~~~~~~~~~~~~
p925.cpp:574:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  574 | iterator
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:574:1: error: invalid use of template-name 'std::iterator' without an argument list
  574 | iterator
      | ^~~~~~~~
p925.cpp:575:1: error: expected ';' at end of member declaration
  575 | const_iterator
      | ^~~~~~~~~~~~~~
      |               ;
p925.cpp:577:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  577 |   iterator
      |   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:578:1: error: expected unqualified-id before 'template'
  578 | template<class K>
      | ^~~~~~~~
p925.cpp:580:1: error: ISO C++ forbids declaration of 'find' with no type [-fpermissive]
  580 | find(const key_type& k) const;
      | ^~~~
p925.cpp:581:27: error: 'K' does not name a type
  581 |                find(const K& k);
      |                           ^
p925.cpp:581:16: error: ISO C++ forbids declaration of 'find' with no type [-fpermissive]
  581 |                find(const K& k);
      |                ^~~~
p925.cpp:582:1: error: 'const_iterator' does not name a type
  582 | const_iterator find(const K& k) const;
      | ^~~~~~~~~~~~~~
p925.cpp:583:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  583 | size_type
      | ^~~~~~~~~
      | size_t
p925.cpp:588:13: error: 'K' does not name a type
  588 | count(const K& k) const;
      |             ^
p925.cpp:588:1: error: ISO C++ forbids declaration of 'count' with no type [-fpermissive]
  588 | count(const K& k) const;
      | ^~~~~
p925.cpp:589:1: error: ISO C++ forbids declaration of 'contains' with no type [-fpermissive]
  589 | contains(const key_type& k) const;
      | ^~~~~~~~
p925.cpp:592:6: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  592 | pair<iterator, iterator>
      |      ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:592:16: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  592 | pair<iterator, iterator>
      |                ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:592:24: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  592 | pair<iterator, iterator>
      |                        ^
p925.cpp:592:24: note:   expected a type, got 'iterator'
p925.cpp:592:24: error: type/value mismatch at argument 2 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
p925.cpp:592:24: note:   expected a type, got 'iterator'
p925.cpp:593:6: error: invalid use of non-static data member 'pmr::std::unordered_multimap<Key, T, Hash, Pred, Allocator>::const_iterator'
  593 | pair<const_iterator, const_iterator>
      |      ^~~~~~~~~~~~~~
p925.cpp:575:1: note: declared here
  575 | const_iterator
      | ^~~~~~~~~~~~~~
p925.cpp:593:22: error: invalid use of non-static data member 'pmr::std::unordered_multimap<Key, T, Hash, Pred, Allocator>::const_iterator'
  593 | pair<const_iterator, const_iterator>
      |                      ^~~~~~~~~~~~~~
p925.cpp:575:1: note: declared here
  575 | const_iterator
      | ^~~~~~~~~~~~~~
p925.cpp:593:36: error: template argument 1 is invalid
  593 | pair<const_iterator, const_iterator>
      |                                    ^
p925.cpp:593:36: error: template argument 2 is invalid
p925.cpp:597:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  597 | size_type max_bucket_count() const noexcept;
      | ^~~~~~~~~
      | size_t
p925.cpp:598:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  598 | size_type bucket_size(size_type n) const;
      | ^~~~~~~~~
      | size_t
p925.cpp:599:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  599 | size_type bucket(const key_type& k) const;
      | ^~~~~~~~~
      | size_t
p925.cpp:600:1: error: 'local_iterator' does not name a type
  600 | local_iterator begin(size_type n);
      | ^~~~~~~~~~~~~~
p925.cpp:601:1: error: 'const_local_iterator' does not name a type
  601 | const_local_iterator begin(size_type n) const;
      | ^~~~~~~~~~~~~~~~~~~~
p925.cpp:602:1: error: 'local_iterator' does not name a type
  602 | local_iterator end(size_type n);
      | ^~~~~~~~~~~~~~
p925.cpp:603:1: error: 'const_local_iterator' does not name a type
  603 | const_local_iterator end(size_type n) const;
      | ^~~~~~~~~~~~~~~~~~~~
p925.cpp:604:1: error: 'const_local_iterator' does not name a type
  604 | const_local_iterator cbegin(size_type n) const;
      | ^~~~~~~~~~~~~~~~~~~~
p925.cpp:605:1: error: 'const_local_iterator' does not name a type
  605 | const_local_iterator cend(size_type n) const;
      | ^~~~~~~~~~~~~~~~~~~~
p925.cpp:610:13: error: 'size_type' has not been declared
  610 | void rehash(size_type n);
      |             ^~~~~~~~~
p925.cpp:611:14: error: 'size_type' has not been declared
  611 | void reserve(size_type n);
      |              ^~~~~~~~~
p925.cpp:612:38: error: ISO C++ forbids declaration of 'equal_range' with no type [-fpermissive]
  612 |                                      equal_range(const key_type& k);
      |                                      ^~~~~~~~~~~
p925.cpp:613:38: error: ISO C++ forbids declaration of 'equal_range' with no type [-fpermissive]
  613 |                                      equal_range(const key_type& k) const;
      |                                      ^~~~~~~~~~~
p925.cpp:614:56: error: 'K' does not name a type
  614 |                                      equal_range(const K& k);
      |                                                        ^
p925.cpp:614:38: error: ISO C++ forbids declaration of 'equal_range' with no type [-fpermissive]
  614 |                                      equal_range(const K& k);
      |                                      ^~~~~~~~~~~
p925.cpp:615:6: error: invalid use of non-static data member 'pmr::std::unordered_multimap<Key, T, Hash, Pred, Allocator>::const_iterator'
  615 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |      ^~~~~~~~~~~~~~
p925.cpp:575:1: note: declared here
  575 | const_iterator
      | ^~~~~~~~~~~~~~
p925.cpp:615:22: error: invalid use of non-static data member 'pmr::std::unordered_multimap<Key, T, Hash, Pred, Allocator>::const_iterator'
  615 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                      ^~~~~~~~~~~~~~
p925.cpp:575:1: note: declared here
  575 | const_iterator
      | ^~~~~~~~~~~~~~
p925.cpp:615:36: error: template argument 1 is invalid
  615 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                    ^
p925.cpp:615:36: error: template argument 2 is invalid
p925.cpp:615:56: error: 'K' does not name a type
  615 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                                        ^
p925.cpp:616:8: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  616 |   pair<iterator, iterator>
      |        ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:616:18: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  616 |   pair<iterator, iterator>
      |                  ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:616:26: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  616 |   pair<iterator, iterator>
      |                          ^
p925.cpp:616:26: note:   expected a type, got 'iterator'
p925.cpp:616:26: error: type/value mismatch at argument 2 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
p925.cpp:616:26: note:   expected a type, got 'iterator'
p925.cpp:617:1: error: expected unqualified-id before 'template'
  617 | template<class K>
      | ^~~~~~~~
p925.cpp:477:68: error: 'see_below' was not declared in this scope
  477 | unordered_multimap(InputIterator f, InputIterator l, size_type n = see_below,
      |                                                                    ^~~~~~~~~
p925.cpp:492:15: error: 'see_below' was not declared in this scope
  492 | size_type n = see_below,
      |               ^~~~~~~~~
p925.cpp:620:19: error: 'iter_key_type' was not declared in this scope
  620 | class Hash = hash<iter_key_type<InputIterator>>,
      |                   ^~~~~~~~~~~~~
p925.cpp:620:46: error: template argument 1 is invalid
  620 | class Hash = hash<iter_key_type<InputIterator>>,
      |                                              ^~
p925.cpp:621:23: error: 'iter' was not declared in this scope
  621 | class Pred = equal_to<iter-key-type<InputIterator>>,
      |                       ^~~~
p925.cpp:621:28: error: 'key' was not declared in this scope; did you mean 'key_t'?
  621 | class Pred = equal_to<iter-key-type<InputIterator>>,
      |                            ^~~
      |                            key_t
p925.cpp:621:32: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  621 | class Pred = equal_to<iter-key-type<InputIterator>>,
      |                                ^~~~
      |                                std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:621:50: error: template argument 1 is invalid
  621 | class Pred = equal_to<iter-key-type<InputIterator>>,
      |                                                  ^~
p925.cpp:622:29: error: 'iter_to_alloc_type' was not declared in this scope
  622 | class Allocator = allocator<iter_to_alloc_type<InputIterator>>>
      |                             ^~~~~~~~~~~~~~~~~~
p925.cpp:622:61: error: template argument 1 is invalid
  622 | class Allocator = allocator<iter_to_alloc_type<InputIterator>>>
      |                                                             ^~
p925.cpp:624:10: error: 'see_below' has not been declared
  624 | typename see_below::size_type = see_below,
      |          ^~~~~~~~~
p925.cpp:624:33: error: 'see_below' was not declared in this scope
  624 | typename see_below::size_type = see_below,
      |                                 ^~~~~~~~~
p925.cpp:626:23: error: 'iter_key_type' was not declared in this scope
  626 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>,
      |                       ^~~~~~~~~~~~~
p925.cpp:626:50: error: wrong number of template arguments (1, should be at least 2)
  626 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:626:23: error: 'iter_key_type' was not declared in this scope
  626 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>,
      |                       ^~~~~~~~~~~~~
p925.cpp:626:50: error: wrong number of template arguments (1, should be at least 2)
  626 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:626:23: error: 'iter_key_type' was not declared in this scope
  626 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>,
      |                       ^~~~~~~~~~~~~
p925.cpp:626:50: error: wrong number of template arguments (1, should be at least 2)
  626 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:626:23: error: 'iter_key_type' was not declared in this scope
  626 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>,
      |                       ^~~~~~~~~~~~~
p925.cpp:626:50: error: wrong number of template arguments (1, should be at least 2)
  626 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:626:4: error: invalid template-id
  626 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>,
      |    ^~~~~~~~~~~~~~~~~~
p925.cpp:626:23: error: 'iter_key_type' was not declared in this scope
  626 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>,
      |                       ^~~~~~~~~~~~~
p925.cpp:626:50: error: expected primary-expression before '>' token
  626 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>,
      |                                                  ^
p925.cpp:626:50: error: trailing return type 'unordered_multimap<...auto...>' of deduction guide is not a specialization of 'pmr::std::unordered_multimap<Key, T, Hash, Pred, Allocator>'
p925.cpp:626:51: error: expected ';' before ',' token
  626 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>,
      |                                                   ^
      |                                                   ;
p925.cpp:629:19: error: 'range_key_type' was not declared in this scope
  629 | class Hash = hash<range_key_type<R>>,
      |                   ^~~~~~~~~~~~~~
p925.cpp:629:35: error: template argument 1 is invalid
  629 | class Hash = hash<range_key_type<R>>,
      |                                   ^~
p925.cpp:630:23: error: 'range_key_type' was not declared in this scope
  630 | class Pred = equal_to<range_key_type<R>>,
      |                       ^~~~~~~~~~~~~~
p925.cpp:630:39: error: template argument 1 is invalid
  630 | class Pred = equal_to<range_key_type<R>>,
      |                                       ^~
p925.cpp:631:29: error: 'range_to_alloc_type' was not declared in this scope
  631 | class Allocator = allocator<range_to_alloc_type<R>>>
      |                             ^~~~~~~~~~~~~~~~~~~
p925.cpp:631:50: error: template argument 1 is invalid
  631 | class Allocator = allocator<range_to_alloc_type<R>>>
      |                                                  ^~
p925.cpp:632:32: error: expected ')' before ',' token
  632 | unordered_multimap(from_range_t, R&&, typename see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      |                   ~            ^
      |                                )
p925.cpp:637:10: error: expected nested-name-specifier before 'see'
  637 | typename see below::size_type = see below,
      |          ^~~
p925.cpp:637:14: error: expected ',' or '...' before 'below'
  637 | typename see below::size_type = see below,
      |              ^~~~~
p925.cpp:641:59: error: expected nested-name-specifier before 'see'
  641 | unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Allocator)
      |                                                           ^~~
p925.cpp:641:63: error: expected ',' or '...' before 'below'
  641 | unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Allocator)
      |                                                               ^~~~~
p925.cpp:642:23: error: 'iter_key_type' was not declared in this scope
  642 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                       ^~~~~~~~~~~~~
p925.cpp:642:50: error: wrong number of template arguments (1, should be at least 2)
  642 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:642:23: error: 'iter_key_type' was not declared in this scope
  642 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                       ^~~~~~~~~~~~~
p925.cpp:642:50: error: wrong number of template arguments (1, should be at least 2)
  642 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:642:23: error: 'iter_key_type' was not declared in this scope
  642 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                       ^~~~~~~~~~~~~
p925.cpp:642:50: error: wrong number of template arguments (1, should be at least 2)
  642 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:642:23: error: 'iter_key_type' was not declared in this scope
  642 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                       ^~~~~~~~~~~~~
p925.cpp:642:50: error: wrong number of template arguments (1, should be at least 2)
  642 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:642:4: error: invalid template-id
  642 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |    ^~~~~~~~~~~~~~~~~~
p925.cpp:642:23: error: 'iter_key_type' was not declared in this scope
  642 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                       ^~~~~~~~~~~~~
p925.cpp:642:50: error: expected primary-expression before '>' token
  642 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                                                  ^
p925.cpp:642:50: error: trailing return type 'unordered_multimap<...auto...>' of deduction guide is not a specialization of 'pmr::std::unordered_multimap<Key, T, Hash, Pred, Allocator>'
p925.cpp:642:51: error: expected ';' before ',' token
  642 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, hash<iter_key_type <InputIterator>>,
      |                                                   ^
      |                                                   ;
p925.cpp:646:23: error: 'iter' was not declared in this scope
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                       ^~~~
p925.cpp:646:28: error: 'key' was not declared in this scope; did you mean 'key_t'?
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                            ^~~
      |                            key_t
p925.cpp:646:32: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                                ^~~~
      |                                std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:646:50: error: wrong number of template arguments (1, should be at least 2)
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:646:23: error: 'iter' was not declared in this scope
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                       ^~~~
p925.cpp:646:28: error: 'key' was not declared in this scope; did you mean 'key_t'?
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                            ^~~
      |                            key_t
p925.cpp:646:32: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                                ^~~~
      |                                std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:646:50: error: wrong number of template arguments (1, should be at least 2)
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:646:23: error: 'iter' was not declared in this scope
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                       ^~~~
p925.cpp:646:28: error: 'key' was not declared in this scope; did you mean 'key_t'?
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                            ^~~
      |                            key_t
p925.cpp:646:32: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                                ^~~~
      |                                std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:646:50: error: wrong number of template arguments (1, should be at least 2)
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:646:23: error: 'iter' was not declared in this scope
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                       ^~~~
p925.cpp:646:28: error: 'key' was not declared in this scope; did you mean 'key_t'?
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                            ^~~
      |                            key_t
p925.cpp:646:32: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                                ^~~~
      |                                std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:646:50: error: wrong number of template arguments (1, should be at least 2)
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:646:4: error: invalid template-id
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |    ^~~~~~~~~~~~~~~~~~
p925.cpp:646:23: error: 'iter' was not declared in this scope
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                       ^~~~
p925.cpp:646:28: error: 'key' was not declared in this scope; did you mean 'key_t'?
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                            ^~~
      |                            key_t
p925.cpp:646:32: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                                ^~~~
      |                                std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:646:50: error: expected primary-expression before '>' token
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                                                  ^
p925.cpp:646:50: error: trailing return type 'unordered_multimap<...auto...>' of deduction guide is not a specialization of 'pmr::std::unordered_multimap<Key, T, Hash, Pred, Allocator>'
p925.cpp:646:51: error: expected ';' before ',' token
  646 | -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, hash<iter-key-type <InputIterator>>,
      |                                                   ^
      |                                                   ;
p925.cpp:649:118: error: expected nested-name-specifier before 'see'
  649 |  class Hash, class Allocator> unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Hash,
      |                                                                                         ^~~

p925.cpp:649:122: error: expected ',' or '...' before 'below'
  649 | ss Hash, class Allocator> unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Hash,
      |                                                                                         ^~~~~

p925.cpp:651:23: error: 'iter_key_type' was not declared in this scope
  651 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash,
      |                       ^~~~~~~~~~~~~
p925.cpp:651:50: error: wrong number of template arguments (1, should be at least 2)
  651 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:651:23: error: 'iter_key_type' was not declared in this scope
  651 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash,
      |                       ^~~~~~~~~~~~~
p925.cpp:651:50: error: wrong number of template arguments (1, should be at least 2)
  651 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:651:23: error: 'iter_key_type' was not declared in this scope
  651 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash,
      |                       ^~~~~~~~~~~~~
p925.cpp:651:50: error: wrong number of template arguments (1, should be at least 2)
  651 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:651:23: error: 'iter_key_type' was not declared in this scope
  651 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash,
      |                       ^~~~~~~~~~~~~
p925.cpp:651:50: error: wrong number of template arguments (1, should be at least 2)
  651 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash,
      |                                                  ^
p925.cpp:451:7: note: provided for 'template<class Key, class T, class Hash, class Pred, class Allocator> class pmr::std::unordered_multimap'
  451 | class unordered_multimap {
      |       ^~~~~~~~~~~~~~~~~~
p925.cpp:651:4: error: invalid template-id
  651 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash,
      |    ^~~~~~~~~~~~~~~~~~
p925.cpp:651:23: error: 'iter_key_type' was not declared in this scope
  651 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash,
      |                       ^~~~~~~~~~~~~
p925.cpp:651:50: error: expected primary-expression before '>' token
  651 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash,
      |                                                  ^
p925.cpp:651:50: error: trailing return type 'unordered_multimap<...auto...>' of deduction guide is not a specialization of 'pmr::std::unordered_multimap<Key, T, Hash, Pred, Allocator>'
p925.cpp:651:51: error: expected ';' before ',' token
  651 | -> unordered_multimap<iter_key_type<InputIterator>, iter_mapped_type<InputIterator>, Hash,
      |                                                   ^
      |                                                   ;
p925.cpp:654:32: error: expected ')' before ',' token
  654 | unordered_multimap(from_range_t, R&&, typename see_below::size_type, Allocator)
      |                   ~            ^
      |                                )
p925.cpp:657:41: error: expected ')' before ',' token
  657 |          unordered_multimap(from_range_t, R&&, Allocator)
      |                            ~            ^
      |                                         )
p925.cpp:659:93: error: expected ')' before ',' token
  659 | late<ranges::input_range R, class Hash, class Allocator> unordered_multimap(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
      |                                                                            ~            ^
      |                                                                                         )
p925.cpp:661:107: error: expected nested-name-specifier before 'see'
  661 | , class T, class Allocator> unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type,
      |                                                                                         ^~~

p925.cpp:661:111: error: expected ',' or '...' before 'below'
  661 | ass T, class Allocator> unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type,
      |                                                                                         ^~~~~

p925.cpp:667:119: error: expected nested-name-specifier before 'see'
  667 | lass Hash, class Allocator> unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type,
      |                                                                                         ^~~

p925.cpp:667:123: error: expected ',' or '...' before 'below'
  667 |  Hash, class Allocator> unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type,
      |                                                                                         ^~~~~

p925.cpp:673:1: error: deduction guide for 'std::unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>' must have trailing return type
  673 | unordered_multimap() : unordered_multimap(size_type(see below)) { } explicit unordered_multimap(size_type n,
      | ^~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/unordered_map.h:73:11: note: 'template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> class std::unordered_multimap' declared here
   73 |     class unordered_multimap;
      |           ^~~~~~~~~~~~~~~~~~
p925.cpp:673:106: error: expected ')' before 'n'
  673 | _multimap() : unordered_multimap(size_type(see below)) { } explicit unordered_multimap(size_type n,
      |                                                                                       ~         ^~
      |                                                                                                 )
p925.cpp:679:1: error: 'size_type' has not been declared
  679 | size_type n = see_below,
      | ^~~~~~~~~
p925.cpp:679:15: error: 'see_below' was not declared in this scope
  679 | size_type n = see_below,
      |               ^~~~~~~~~
p925.cpp:680:7: error: 'hasher' does not name a type
  680 | const hasher& hf = hasher(),
      |       ^~~~~~
p925.cpp:680:20: error: there are no arguments to 'hasher' that depend on a template parameter, so a declaration of 'hasher' must be available [-fpermissive]
  680 | const hasher& hf = hasher(),
      |                    ^~~~~~
p925.cpp:681:7: error: 'key_equal' does not name a type
  681 | const key_equal& eql = key_equal(),
      |       ^~~~~~~~~
p925.cpp:681:24: error: there are no arguments to 'key_equal' that depend on a template parameter, so a declaration of 'key_equal' must be available [-fpermissive]
  681 | const key_equal& eql = key_equal(),
      |                        ^~~~~~~~~
p925.cpp:682:7: error: 'allocator_type' does not name a type
  682 | const allocator_type& a = allocator_type());
      |       ^~~~~~~~~~~~~~
p925.cpp:682:27: error: there are no arguments to 'allocator_type' that depend on a template parameter, so a declaration of 'allocator_type' must be available [-fpermissive]
  682 | const allocator_type& a = allocator_type());
      |                           ^~~~~~~~~~~~~~
p925.cpp:678:3: error: deduction guide for 'std::unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>' must have trailing return type
  678 |   unordered_multimap(InputIterator f, InputIterator l,
      |   ^~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/unordered_map.h:73:11: note: 'template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> class std::unordered_multimap' declared here
   73 |     class unordered_multimap;
      |           ^~~~~~~~~~~~~~~~~~
p925.cpp:683:37: error: 'value_type' was not declared in this scope
  683 | template<container_compatible_range<value_type> R> unordered_multimap(from_range_t, R&& rg,
      |                                     ^~~~~~~~~~
p925.cpp:683:37: error: 'value_type' was not declared in this scope
p925.cpp:683:37: error: 'value_type' was not declared in this scope
p925.cpp:683:37: error: 'value_type' was not declared in this scope
p925.cpp:683:37: error: 'value_type' was not declared in this scope
p925.cpp:683:37: error: 'value_type' was not declared in this scope
p925.cpp:683:10: error: 'container_compatible_range' has not been declared
  683 | template<container_compatible_range<value_type> R> unordered_multimap(from_range_t, R&& rg,
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp:683:36: error: expected '>' before '<' token
  683 | template<container_compatible_range<value_type> R> unordered_multimap(from_range_t, R&& rg,
      |                                    ^
p925.cpp:683:83: error: expected ')' before ',' token
  683 | template<container_compatible_range<value_type> R> unordered_multimap(from_range_t, R&& rg,
      |                                                                      ~            ^
      |                                                                                   )
p925.cpp:688:37: error: 'value_type' was not declared in this scope
  688 | unordered_multimap(initializer_list<value_type> il,
      |                                     ^~~~~~~~~~
p925.cpp:688:47: error: template argument 1 is invalid
  688 | unordered_multimap(initializer_list<value_type> il,
      |                                               ^
p925.cpp:689:1: error: 'size_type' has not been declared
  689 | size_type n = see_below,
      | ^~~~~~~~~
p925.cpp:689:15: error: 'see_below' was not declared in this scope
  689 | size_type n = see_below,
      |               ^~~~~~~~~
p925.cpp:690:7: error: 'hasher' does not name a type
  690 | const hasher& hf = hasher(),
      |       ^~~~~~
p925.cpp:690:20: error: 'hasher' was not declared in this scope
  690 | const hasher& hf = hasher(),
      |                    ^~~~~~
p925.cpp:691:7: error: 'key_equal' does not name a type
  691 | const key_equal& eql = key_equal(),
      |       ^~~~~~~~~
p925.cpp:691:24: error: 'key_equal' was not declared in this scope
  691 | const key_equal& eql = key_equal(),
      |                        ^~~~~~~~~
p925.cpp:692:7: error: 'allocator_type' does not name a type
  692 | const allocator_type& a = allocator_type());
      |       ^~~~~~~~~~~~~~
p925.cpp:692:27: error: 'allocator_type' was not declared in this scope
  692 | const allocator_type& a = allocator_type());
      |                           ^~~~~~~~~~~~~~
p925.cpp:688:1: error: deduction guide for 'std::unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>' must have trailing return type
  688 | unordered_multimap(initializer_list<value_type> il,
      | ^~~~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/unordered_map.h:73:11: note: 'template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> class std::unordered_multimap' declared here
   73 |     class unordered_multimap;
      |           ^~~~~~~~~~~~~~~~~~
p925.cpp:697:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  697 |   iterator insert(P&& obj);
      |   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:697:3: error: deduced class type 'iterator' in function return type
  697 |   iterator insert(P&& obj);
      |   ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:700:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  700 |   iterator insert(const_iterator hint, P&& obj);
      |   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:700:19: error: 'template<class P> iterator<...auto...> pmr::insert' conflicts with a previous declaration
  700 |   iterator insert(const_iterator hint, P&& obj);
      |                   ^~~~~~~~~~~~~~
p925.cpp:386:24: note: previous declaration 'int pmr::insert(P&&)'
  386 |   pair<iterator, bool> insert(P&& obj);
      |                        ^~~~~~
p925.cpp:700:19: error: 'const_iterator' was not declared in this scope
  700 |   iterator insert(const_iterator hint, P&& obj);
      |                   ^~~~~~~~~~~~~~
p925.cpp:700:41: error: expected primary-expression before '&&' token
  700 |   iterator insert(const_iterator hint, P&& obj);
      |                                         ^~
p925.cpp:700:44: error: 'obj' was not declared in this scope
  700 |   iterator insert(const_iterator hint, P&& obj);
      |                                            ^~~
p925.cpp:702:8: error: found ':' in nested-name-specifier, expected '::'
  702 | Effects: Equivalent to: return emplace_hint(hint, std::forward<P>(obj));
      |        ^
      |        ::
p925.cpp:702:1: error: 'Effects' does not name a type
  702 | Effects: Equivalent to: return emplace_hint(hint, std::forward<P>(obj));
      | ^~~~~~~
p925.cpp:708:29: error: 'c' was not declared in this scope
  708 |        auto original_size = c.size();
      |                             ^
p925.cpp:709:8: error: expected unqualified-id before 'for'
  709 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |        ^~~
p925.cpp:709:49: error: 'i' does not name a type
  709 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                                 ^
p925.cpp:709:60: error: expected unqualified-id before ')' token
  709 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                                            ^
p925.cpp:714:8: error: expected unqualified-id before 'return'
  714 |        return original_size - c.size();
      |        ^~~~~~
p925.cpp:737:21: error: 'implementation_defined' does not name a type
  737 |   using size_type = implementation_defined ; // see 24.2
      |                     ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:738:27: error: 'implementation_defined' does not name a type
  738 |   using difference_type = implementation_defined ; // see 24.2
      |                           ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:739:20: error: 'implementation_defined' does not name a type
  739 |   using iterator = implementation_defined ; // see 24.2
      |                    ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:740:26: error: 'implementation_defined' does not name a type
  740 |   using const_iterator = implementation_defined ; // see 24.2
      |                          ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:741:26: error: 'implementation_defined' does not name a type
  741 |   using local_iterator = implementation_defined ; // see 24.2
      |                          ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:742:32: error: 'implementation_defined' does not name a type
  742 |   using const_local_iterator = implementation_defined ; // see 24.2
      |                                ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:743:22: error: 'unspecified' does not name a type
  743 |   using node_type  = unspecified;
      |                      ^~~~~~~~~~~
p925.cpp:744:30: error: 'insert' does not name a type; did you mean 'assert'?
  744 |   using insert_return_type = insert-return-type<iterator, node_type>;
      |                              ^~~~~~
      |                              assert
p925.cpp:746:33: error: expected ')' before 'n'
  746 | explicit unordered_set(size_type n,
      |                       ~         ^~
      |                                 )
p925.cpp:752:1: error: 'size_type' has not been declared
  752 | size_type n = see_below,
      | ^~~~~~~~~
p925.cpp:756:10: error: 'container_compatible_range' has not been declared
  756 | template<container_compatible_range<value_type> R> unordered_set(from_range_t, R&& rg,
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp:756:36: error: expected '>' before '<' token
  756 | template<container_compatible_range<value_type> R> unordered_set(from_range_t, R&& rg,
      |                                    ^
p925.cpp:756:78: error: expected ')' before ',' token
  756 | template<container_compatible_range<value_type> R> unordered_set(from_range_t, R&& rg,
      |                                                                 ~            ^
      |                                                                              )
p925.cpp:767:1: error: 'size_type' has not been declared
  767 | size_type n = see below,
      | ^~~~~~~~~
p925.cpp:771:24: error: expected ')' before 'n'
  771 | unordered_set(size_type n, const allocator_type& a)
      |              ~         ^~
      |                        )
p925.cpp:773:24: error: expected ')' before 'n'
  773 | unordered_set(size_type n, const hasher& hf, const allocator_type& a)
      |              ~         ^~
      |                        )
p925.cpp:776:51: error: 'size_type' has not been declared
  776 |   unordered_set(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
      |                                                   ^~~~~~~~~
p925.cpp:779:51: error: 'size_type' has not been declared
  779 |   unordered_set(InputIterator f, InputIterator l, size_type n, const hasher& hf,
      |                                                   ^~~~~~~~~
p925.cpp:782:48: error: 'size_type' has not been declared
  782 | unordered_set(initializer_list<value_type> il, size_type n, const allocator_type& a)
      |                                                ^~~~~~~~~
p925.cpp:784:10: error: 'container_compatible_range' has not been declared
  784 | template<container_compatible_range<value_type> R> unordered_set(from_range_t, R&& rg, size_type n, const allocator_type& a)
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp:784:36: error: expected '>' before '<' token
  784 | template<container_compatible_range<value_type> R> unordered_set(from_range_t, R&& rg, size_type n, const allocator_type& a)
      |                                    ^
p925.cpp:784:78: error: expected ')' before ',' token
  784 | template<container_compatible_range<value_type> R> unordered_set(from_range_t, R&& rg, size_type n, const allocator_type& a)
      |                                                                 ~            ^
      |                                                                              )
p925.cpp:785:92: error: 'container_compatible_range' has not been declared
  785 | nordered_set(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } template<container_compatible_range<value_type> R>
      |                                                                                         ^~~~~~~~~~~~~~~~~~~~~~~~~~

p925.cpp:785:118: error: expected '>' before '<' token
  785 | td::forward<R>(rg), n, hasher(), key_equal(), a) { } template<container_compatible_range<value_type> R>
      |                                                                                         ^

p925.cpp:786:29: error: expected ')' before ',' token
  786 |   unordered_set(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
      |                ~            ^
      |                             )
p925.cpp:788:48: error: 'size_type' has not been declared
  788 | unordered_set(initializer_list<value_type> il, size_type n, const hasher& hf,
      |                                                ^~~~~~~~~
p925.cpp:798:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  798 | iterator       begin() noexcept;
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:798:1: error: deduced class type 'iterator' in function return type
  798 | 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
      |                                  ^~~~~~~~
p925.cpp:799:1: error: 'const_iterator' does not name a type
  799 | const_iterator begin() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:800:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  800 | 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
      |                                  ^~~~~~~~
p925.cpp:800:1: error: deduced class type 'iterator' in function return type
  800 | 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
      |                                  ^~~~~~~~
p925.cpp:801:1: error: 'const_iterator' does not name a type
  801 | const_iterator end() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:802:1: error: 'const_iterator' does not name a type
  802 | const_iterator cbegin() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:803:1: error: 'const_iterator' does not name a type
  803 | const_iterator cend() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:806:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  806 | size_type size() const noexcept;
      | ^~~~~~~~~
      | size_t
p925.cpp:807:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  807 | size_type max_size() const noexcept;
      | ^~~~~~~~~
      | size_t
p925.cpp:809:30: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  809 | template<class... Args> pair<iterator, bool> emplace(Args&&... args);
      |                              ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:809:44: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  809 | template<class... Args> pair<iterator, bool> emplace(Args&&... args);
      |                                            ^
p925.cpp:809:44: note:   expected a type, got 'iterator'
p925.cpp:810:25: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  810 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
      |                         ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:810:47: error: 'const_iterator' has not been declared
  810 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
      |                                               ^~~~~~~~~~~~~~
p925.cpp:810:25: error: deduced class type 'iterator' in function return type
  810 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
      |                         ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:810:94: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  810 | ate<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
      |                                                                                         ^~~~~~~~

/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:810:108: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  810 | rgs> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj);
      |                                                                                         ^

p925.cpp:810:108: note:   expected a type, got 'iterator'
p925.cpp:811:6: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  811 | pair<iterator, bool> insert(value_type&& obj);
      |      ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:811:20: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  811 | pair<iterator, bool> insert(value_type&& obj);
      |                    ^
p925.cpp:811:20: note:   expected a type, got 'iterator'
p925.cpp:812:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  812 | iterator insert(const_iterator hint, const value_type& obj);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:812:17: error: 'const_iterator' has not been declared
  812 | iterator insert(const_iterator hint, const value_type& obj);
      |                 ^~~~~~~~~~~~~~
p925.cpp:812:1: error: deduced class type 'iterator' in function return type
  812 | iterator insert(const_iterator hint, const value_type& obj);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:813:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  813 | iterator insert(const_iterator hint, value_type&& obj);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:813:17: error: 'const_iterator' has not been declared
  813 | iterator insert(const_iterator hint, value_type&& obj);
      |                 ^~~~~~~~~~~~~~
p925.cpp:813:1: error: deduced class type 'iterator' in function return type
  813 | iterator insert(const_iterator hint, value_type&& obj);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:814:94: error: 'container' has not been declared
  814 | ate<class InputIterator> void insert(InputIterator first, InputIterator last); template<container-compatible-range<value_type> R>
      |                                                                                         ^~~~~~~~~

p925.cpp:814:103: error: expected '>' before '-' token
  814 |  InputIterator> void insert(InputIterator first, InputIterator last); template<container-compatible-range<value_type> R>
      |                                                                                         ^

p925.cpp:815:21: error: 'R' has not been declared
  815 |   void insert_range(R&& rg);
      |                     ^
p925.cpp:817:1: error: 'node_type' does not name a type
  817 | node_type extract(const_iterator position);
      | ^~~~~~~~~
p925.cpp:818:1: error: 'node_type' does not name a type
  818 | node_type extract(const key_type& x);
      | ^~~~~~~~~
p925.cpp:819:19: error: 'node_type' does not name a type
  819 | template<class K> node_type extract(K&& x);
      |                   ^~~~~~~~~
p925.cpp:820:1: error: 'insert_return_type' does not name a type
  820 | insert_return_type insert(node_type&& nh);
      | ^~~~~~~~~~~~~~~~~~
p925.cpp:821:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  821 | iterator           insert(const_iterator hint, node_type&& nh);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:821:27: error: 'const_iterator' has not been declared
  821 | iterator           insert(const_iterator hint, node_type&& nh);
      |                           ^~~~~~~~~~~~~~
p925.cpp:821:48: error: 'node_type' has not been declared
  821 | iterator           insert(const_iterator hint, node_type&& nh);
      |                                                ^~~~~~~~~
p925.cpp:821:1: error: deduced class type 'iterator' in function return type
  821 | iterator           insert(const_iterator hint, node_type&& nh);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:822:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  822 | iterator  erase(iterator position);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:822:17: error: class template placeholder 'std::iterator' not permitted in this context
  822 | iterator  erase(iterator position);
      |                 ^~~~~~~~
p925.cpp:822:17: note: use 'auto' for an abbreviated function template
p925.cpp:822:1: error: deduced class type 'iterator' in function return type
  822 | iterator  erase(iterator position);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:823:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  823 | iterator  erase(const_iterator position);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:823:17: error: 'const_iterator' has not been declared
  823 | iterator  erase(const_iterator position);
      |                 ^~~~~~~~~~~~~~
p925.cpp:823:1: error: deduced class type 'iterator' in function return type
  823 | iterator  erase(const_iterator position);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:824:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  824 | size_type erase(const key_type& k);
      | ^~~~~~~~~
      | size_t
p925.cpp:825:19: error: 'size_type' does not name a type; did you mean 'size_t'?
  825 | template<class K> size_type erase(K&& x);
      |                   ^~~~~~~~~
      |                   size_t
p925.cpp:826:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  826 | 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
      |                                  ^~~~~~~~
p925.cpp:826:17: error: 'const_iterator' has not been declared
  826 | iterator  erase(const_iterator first, const_iterator last);
      |                 ^~~~~~~~~~~~~~
p925.cpp:826:39: error: 'const_iterator' has not been declared
  826 | iterator  erase(const_iterator first, const_iterator last);
      |                                       ^~~~~~~~~~~~~~
p925.cpp:826:1: error: deduced class type 'iterator' in function return type
  826 | iterator  erase(const_iterator first, const_iterator last);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:837:14: error: 'unordered_multiset' has not been declared
  837 |   void merge(unordered_multiset<Key, H2, P2, Allocator>& source);
      |              ^~~~~~~~~~~~~~~~~~
p925.cpp:837:32: error: expected ',' or '...' before '<' token
  837 |   void merge(unordered_multiset<Key, H2, P2, Allocator>& source);
      |                                ^
p925.cpp:839:14: error: 'unordered_multiset' has not been declared
  839 |   void merge(unordered_multiset<Key, H2, P2, Allocator>&& source);
      |              ^~~~~~~~~~~~~~~~~~
p925.cpp:839:32: error: expected ',' or '...' before '<' token
  839 |   void merge(unordered_multiset<Key, H2, P2, Allocator>&& source);
      |                                ^
p925.cpp:839:8: error: 'template<class Key, class Hash, class Pred, class Allocator> template<class H2, class P2> void pmr::std::unordered_set<Key, Hash, Pred, Allocator>::merge(int)' cannot be overloaded with 'template<class Key, class Hash, class Pred, class Allocator> template<class H2, class P2> void pmr::std::unordered_set<Key, Hash, Pred, Allocator>::merge(int)'
  839 |   void merge(unordered_multiset<Key, H2, P2, Allocator>&& source);
      |        ^~~~~
p925.cpp:837:8: note: previous declaration 'template<class Key, class Hash, class Pred, class Allocator> template<class H2, class P2> void pmr::std::unordered_set<Key, Hash, Pred, Allocator>::merge(int)'
  837 |   void merge(unordered_multiset<Key, H2, P2, Allocator>& source);
      |        ^~~~~
p925.cpp:844:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  844 | iterator
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:844:1: error: invalid use of template-name 'std::iterator' without an argument list
  844 | iterator
      | ^~~~~~~~
p925.cpp:845:1: error: expected ';' at end of member declaration
  845 | const_iterator
      | ^~~~~~~~~~~~~~
      |               ;
p925.cpp:847:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  847 |   iterator
      |   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:848:1: error: expected unqualified-id before 'template'
  848 | template<class K>
      | ^~~~~~~~
p925.cpp:850:1: error: ISO C++ forbids declaration of 'find' with no type [-fpermissive]
  850 | find(const key_type& k) const;
      | ^~~~
p925.cpp:851:12: error: 'K' does not name a type
  851 | find(const K& k);
      |            ^
p925.cpp:851:1: error: ISO C++ forbids declaration of 'find' with no type [-fpermissive]
  851 | find(const K& k);
      | ^~~~
p925.cpp:852:3: error: 'const_iterator' does not name a type
  852 |   const_iterator find(const K& k) const;
      |   ^~~~~~~~~~~~~~
p925.cpp:853:1: error: 'size_type' does not name a type; did you mean 'size_t'?
  853 | size_type        count(const key_type& k) const;
      | ^~~~~~~~~
      | size_t
p925.cpp:855:3: error: 'size_type' does not name a type; did you mean 'size_t'?
  855 |   size_type      count(const K& k) const;
      |   ^~~~~~~~~
      |   size_t
p925.cpp:859:10: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  859 |     pair<iterator, iterator>
      |          ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:859:20: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  859 |     pair<iterator, iterator>
      |                    ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:859:28: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  859 |     pair<iterator, iterator>
      |                            ^
p925.cpp:859:28: note:   expected a type, got 'iterator'
p925.cpp:859:28: error: type/value mismatch at argument 2 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
p925.cpp:859:28: note:   expected a type, got 'iterator'
p925.cpp:860:10: error: invalid use of non-static data member 'pmr::std::unordered_set<Key, Hash, Pred, Allocator>::const_iterator'
  860 |     pair<const_iterator, const_iterator>
      |          ^~~~~~~~~~~~~~
p925.cpp:845:1: note: declared here
  845 | const_iterator
      | ^~~~~~~~~~~~~~
p925.cpp:860:26: error: invalid use of non-static data member 'pmr::std::unordered_set<Key, Hash, Pred, Allocator>::const_iterator'
  860 |     pair<const_iterator, const_iterator>
      |                          ^~~~~~~~~~~~~~
p925.cpp:845:1: note: declared here
  845 | const_iterator
      | ^~~~~~~~~~~~~~
p925.cpp:860:40: error: template argument 1 is invalid
  860 |     pair<const_iterator, const_iterator>
      |                                        ^
p925.cpp:860:40: error: template argument 2 is invalid
p925.cpp:864:5: error: 'size_type' does not name a type; did you mean 'size_t'?
  864 |     size_type max_bucket_count() const noexcept;
      |     ^~~~~~~~~
      |     size_t
p925.cpp:865:5: error: 'size_type' does not name a type; did you mean 'size_t'?
  865 |     size_type bucket_size(size_type n) const;
      |     ^~~~~~~~~
      |     size_t
p925.cpp:866:5: error: 'size_type' does not name a type; did you mean 'size_t'?
  866 |     size_type bucket(const key_type& k) const;
      |     ^~~~~~~~~
      |     size_t
p925.cpp:867:5: error: 'local_iterator' does not name a type
  867 |     local_iterator begin(size_type n);
      |     ^~~~~~~~~~~~~~
p925.cpp:868:5: error: 'const_local_iterator' does not name a type
  868 |     const_local_iterator begin(size_type n) const;
      |     ^~~~~~~~~~~~~~~~~~~~
p925.cpp:869:5: error: 'local_iterator' does not name a type
  869 |     local_iterator end(size_type n);
      |     ^~~~~~~~~~~~~~
p925.cpp:870:5: error: 'const_local_iterator' does not name a type
  870 |     const_local_iterator end(size_type n) const;
      |     ^~~~~~~~~~~~~~~~~~~~
p925.cpp:871:5: error: 'const_local_iterator' does not name a type
  871 |     const_local_iterator cbegin(size_type n) const;
      |     ^~~~~~~~~~~~~~~~~~~~
p925.cpp:872:5: error: 'const_local_iterator' does not name a type
  872 |     const_local_iterator cend(size_type n) const;
      |     ^~~~~~~~~~~~~~~~~~~~
p925.cpp:877:17: error: 'size_type' has not been declared
  877 |     void rehash(size_type n);
      |                 ^~~~~~~~~
p925.cpp:878:18: error: 'size_type' has not been declared
  878 |     void reserve(size_type n);
      |                  ^~~~~~~~~
p925.cpp:752:15: error: 'see_below' was not declared in this scope
  752 | size_type n = see_below,
      |               ^~~~~~~~~
p925.cpp:767:15: error: 'see' was not declared in this scope
  767 | size_type n = see below,
      |               ^~~
p925.cpp:881:19: error: 'iter_value_type' was not declared in this scope
  881 | class Hash = hash<iter_value_type<InputIterator>>,
      |                   ^~~~~~~~~~~~~~~
p925.cpp:881:48: error: template argument 1 is invalid
  881 | class Hash = hash<iter_value_type<InputIterator>>,
      |                                                ^~
p925.cpp:882:23: error: 'iter_value_type' was not declared in this scope
  882 | class Pred = equal_to<iter_value_type<InputIterator>>,
      |                       ^~~~~~~~~~~~~~~
p925.cpp:882:52: error: template argument 1 is invalid
  882 | class Pred = equal_to<iter_value_type<InputIterator>>,
      |                                                    ^~
p925.cpp:883:29: error: 'iter' was not declared in this scope
  883 | class Allocator = allocator<iter-value-type<InputIterator>>>
      |                             ^~~~
p925.cpp:883:34: error: 'value' was not declared in this scope
  883 | class Allocator = allocator<iter-value-type<InputIterator>>>
      |                                  ^~~~~
p925.cpp:883:40: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  883 | class Allocator = allocator<iter-value-type<InputIterator>>>
      |                                        ^~~~
      |                                        std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:883:58: error: template argument 1 is invalid
  883 | class Allocator = allocator<iter-value-type<InputIterator>>>
      |                                                          ^~
p925.cpp:884:54: error: 'see_below' has not been declared
  884 | unordered_set(InputIterator, InputIterator, typename see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      |                                                      ^~~~~~~~~
p925.cpp:884:77: error: 'see_below' was not declared in this scope
  884 | unordered_set(InputIterator, InputIterator, typename see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      |                                                                             ^~~~~~~~~
p925.cpp:885:18: error: 'iter' was not declared in this scope
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                  ^~~~
p925.cpp:885:23: error: 'value' was not declared in this scope
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                       ^~~~~
p925.cpp:885:29: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                             ^~~~
      |                             std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:885:47: error: template argument 1 is invalid
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                               ^
p925.cpp:885:47: error: template argument 2 is invalid
p925.cpp:885:47: error: template argument 3 is invalid
p925.cpp:885:47: error: template argument 4 is invalid
p925.cpp:885:18: error: 'iter' was not declared in this scope
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                  ^~~~
p925.cpp:885:23: error: 'value' was not declared in this scope
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                       ^~~~~
p925.cpp:885:29: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                             ^~~~
      |                             std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:885:47: error: template argument 1 is invalid
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                               ^
p925.cpp:885:47: error: template argument 2 is invalid
p925.cpp:885:47: error: template argument 3 is invalid
p925.cpp:885:47: error: template argument 4 is invalid
p925.cpp:885:18: error: 'iter' was not declared in this scope
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                  ^~~~
p925.cpp:885:23: error: 'value' was not declared in this scope
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                       ^~~~~
p925.cpp:885:29: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                             ^~~~
      |                             std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:885:47: error: template argument 1 is invalid
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                               ^
p925.cpp:885:47: error: template argument 2 is invalid
p925.cpp:885:47: error: template argument 3 is invalid
p925.cpp:885:47: error: template argument 4 is invalid
p925.cpp:885:18: error: 'iter' was not declared in this scope
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                  ^~~~
p925.cpp:885:23: error: 'value' was not declared in this scope
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                       ^~~~~
p925.cpp:885:29: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                             ^~~~
      |                             std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:885:47: error: template argument 1 is invalid
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                               ^
p925.cpp:885:47: error: template argument 2 is invalid
p925.cpp:885:47: error: template argument 3 is invalid
p925.cpp:885:47: error: template argument 4 is invalid
p925.cpp:885:4: error: invalid template-id
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |    ^~~~~~~~~~~~~
p925.cpp:885:18: error: 'iter' was not declared in this scope
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                  ^~~~
p925.cpp:885:23: error: 'value' was not declared in this scope
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                       ^~~~~
p925.cpp:885:29: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                             ^~~~
      |                             std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:885:47: error: expected primary-expression before '>' token
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                               ^
p925.cpp:885:47: error: trailing return type 'unordered_set<...auto...>' of deduction guide is not a specialization of 'pmr::std::unordered_set<Key, Hash, Pred, Allocator>'
p925.cpp:885:48: error: expected ';' before ',' token
  885 | -> unordered_set<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                                ^
      |                                                ;
p925.cpp:890:27: error: expected ')' before ',' token
  890 | unordered_set(from_range_t, R&&, typename see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      |              ~            ^
      |                           )
p925.cpp:892:56: error: 'key_type' does not name a type; did you mean 'key_t'?
  892 |                                      equal_range(const key_type& k) const;
      |                                                        ^~~~~~~~
      |                                                        key_t
p925.cpp:892:74: error: expected constructor, destructor, or type conversion before ';' token
  892 |                                      equal_range(const key_type& k) const;
      |                                                                          ^
p925.cpp:893:56: error: 'K' does not name a type
  893 |                                      equal_range(const K& k);
      |                                                        ^
p925.cpp:893:61: error: expected constructor, destructor, or type conversion before ';' token
  893 |                                      equal_range(const K& k);
      |                                                             ^
p925.cpp:894:6: error: 'const_iterator' was not declared in this scope
  894 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |      ^~~~~~~~~~~~~~
p925.cpp:894:22: error: 'const_iterator' was not declared in this scope
  894 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                      ^~~~~~~~~~~~~~
p925.cpp:894:36: error: template argument 1 is invalid
  894 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                    ^
p925.cpp:894:36: error: template argument 2 is invalid
p925.cpp:894:56: error: 'K' does not name a type
  894 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                                        ^
p925.cpp:894:62: error: non-member function 'int pmr::std::equal_range(const int&)' cannot have cv-qualifier
  894 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                                              ^~~~~
p925.cpp:895:8: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  895 |   pair<iterator, iterator>
      |        ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:895:18: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
  895 |   pair<iterator, iterator>
      |                  ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:895:26: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
  895 |   pair<iterator, iterator>
      |                          ^
p925.cpp:895:26: note:   expected a type, got 'iterator'
p925.cpp:895:26: error: type/value mismatch at argument 2 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
p925.cpp:895:26: note:   expected a type, got 'iterator'
p925.cpp:896:1: error: expected unqualified-id before 'template'
  896 | template<class K>
      | ^~~~~~~~
p925.cpp:902:45: error: 'see_below' has not been declared
  902 | unordered_set(initializer_list<T>, typename see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      |                                             ^~~~~~~~~
p925.cpp:902:68: error: 'see_below' was not declared in this scope
  902 | unordered_set(initializer_list<T>, typename see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      |                                                                    ^~~~~~~~~
p925.cpp:905:54: error: expected nested-name-specifier before 'see'
  905 | unordered_set(InputIterator, InputIterator, typename see below::size_type, Allocator)
      |                                                      ^~~
p925.cpp:905:58: error: expected ',' or '...' before 'below'
  905 | unordered_set(InputIterator, InputIterator, typename see below::size_type, Allocator)
      |                                                          ^~~~~
p925.cpp:906:18: error: 'iter_value_type' was not declared in this scope
  906 | -> unordered_set<iter_value_type<InputIterator>, hash<iter_value_type <InputIterator>>,
      |                  ^~~~~~~~~~~~~~~
p925.cpp:906:47: error: template argument 1 is invalid
  906 | -> unordered_set<iter_value_type<InputIterator>, hash<iter_value_type <InputIterator>>,
      |                                               ^
p925.cpp:906:47: error: template argument 2 is invalid
p925.cpp:906:47: error: template argument 3 is invalid
p925.cpp:906:47: error: template argument 4 is invalid
p925.cpp:906:18: error: 'iter_value_type' was not declared in this scope
  906 | -> unordered_set<iter_value_type<InputIterator>, hash<iter_value_type <InputIterator>>,
      |                  ^~~~~~~~~~~~~~~
p925.cpp:906:47: error: template argument 1 is invalid
  906 | -> unordered_set<iter_value_type<InputIterator>, hash<iter_value_type <InputIterator>>,
      |                                               ^
p925.cpp:906:47: error: template argument 2 is invalid
p925.cpp:906:47: error: template argument 3 is invalid
p925.cpp:906:47: error: template argument 4 is invalid
p925.cpp:906:18: error: 'iter_value_type' was not declared in this scope
  906 | -> unordered_set<iter_value_type<InputIterator>, hash<iter_value_type <InputIterator>>,
      |                  ^~~~~~~~~~~~~~~
p925.cpp:906:47: error: template argument 1 is invalid
  906 | -> unordered_set<iter_value_type<InputIterator>, hash<iter_value_type <InputIterator>>,
      |                                               ^
p925.cpp:906:47: error: template argument 2 is invalid
p925.cpp:906:47: error: template argument 3 is invalid
p925.cpp:906:47: error: template argument 4 is invalid
p925.cpp:906:18: error: 'iter_value_type' was not declared in this scope
  906 | -> unordered_set<iter_value_type<InputIterator>, hash<iter_value_type <InputIterator>>,
      |                  ^~~~~~~~~~~~~~~
p925.cpp:906:47: error: template argument 1 is invalid
  906 | -> unordered_set<iter_value_type<InputIterator>, hash<iter_value_type <InputIterator>>,
      |                                               ^
p925.cpp:906:47: error: template argument 2 is invalid
p925.cpp:906:47: error: template argument 3 is invalid
p925.cpp:906:47: error: template argument 4 is invalid
p925.cpp:906:4: error: invalid template-id
  906 | -> unordered_set<iter_value_type<InputIterator>, hash<iter_value_type <InputIterator>>,
      |    ^~~~~~~~~~~~~
p925.cpp:906:18: error: 'iter_value_type' was not declared in this scope
  906 | -> unordered_set<iter_value_type<InputIterator>, hash<iter_value_type <InputIterator>>,
      |                  ^~~~~~~~~~~~~~~
p925.cpp:906:47: error: expected primary-expression before '>' token
  906 | -> unordered_set<iter_value_type<InputIterator>, hash<iter_value_type <InputIterator>>,
      |                                               ^
p925.cpp:906:47: error: trailing return type 'unordered_set<...auto...>' of deduction guide is not a specialization of 'pmr::std::unordered_set<Key, Hash, Pred, Allocator>'
p925.cpp:906:48: error: expected ';' before ',' token
  906 | -> unordered_set<iter_value_type<InputIterator>, hash<iter_value_type <InputIterator>>,
      |                                                ^
      |                                                ;
p925.cpp:908:113: error: expected nested-name-specifier before 'see'
  908 | ator, class Hash, class Allocator> unordered_set(InputIterator, InputIterator, typename see below::size_type,
      |                                                                                         ^~~

p925.cpp:908:117: error: expected ',' or '...' before 'below'
  908 | , class Hash, class Allocator> unordered_set(InputIterator, InputIterator, typename see below::size_type,
      |                                                                                         ^~~~~

p925.cpp:910:18: error: 'iter' was not declared in this scope
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                  ^~~~
p925.cpp:910:23: error: 'value' was not declared in this scope
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                       ^~~~~
p925.cpp:910:29: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                             ^~~~
      |                             std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:910:47: error: template argument 1 is invalid
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                                               ^
p925.cpp:910:47: error: template argument 2 is invalid
p925.cpp:910:47: error: template argument 3 is invalid
p925.cpp:910:47: error: template argument 4 is invalid
p925.cpp:910:18: error: 'iter' was not declared in this scope
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                  ^~~~
p925.cpp:910:23: error: 'value' was not declared in this scope
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                       ^~~~~
p925.cpp:910:29: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                             ^~~~
      |                             std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:910:47: error: template argument 1 is invalid
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                                               ^
p925.cpp:910:47: error: template argument 2 is invalid
p925.cpp:910:47: error: template argument 3 is invalid
p925.cpp:910:47: error: template argument 4 is invalid
p925.cpp:910:18: error: 'iter' was not declared in this scope
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                  ^~~~
p925.cpp:910:23: error: 'value' was not declared in this scope
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                       ^~~~~
p925.cpp:910:29: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                             ^~~~
      |                             std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:910:47: error: template argument 1 is invalid
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                                               ^
p925.cpp:910:47: error: template argument 2 is invalid
p925.cpp:910:47: error: template argument 3 is invalid
p925.cpp:910:47: error: template argument 4 is invalid
p925.cpp:910:18: error: 'iter' was not declared in this scope
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                  ^~~~
p925.cpp:910:23: error: 'value' was not declared in this scope
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                       ^~~~~
p925.cpp:910:29: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                             ^~~~
      |                             std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:910:47: error: template argument 1 is invalid
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                                               ^
p925.cpp:910:47: error: template argument 2 is invalid
p925.cpp:910:47: error: template argument 3 is invalid
p925.cpp:910:47: error: template argument 4 is invalid
p925.cpp:910:4: error: invalid template-id
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |    ^~~~~~~~~~~~~
p925.cpp:910:18: error: 'iter' was not declared in this scope
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                  ^~~~
p925.cpp:910:23: error: 'value' was not declared in this scope
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                       ^~~~~
p925.cpp:910:29: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                             ^~~~
      |                             std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:910:47: error: expected primary-expression before '>' token
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                                               ^
p925.cpp:910:47: error: trailing return type 'unordered_set<...auto...>' of deduction guide is not a specialization of 'pmr::std::unordered_set<Key, Hash, Pred, Allocator>'
p925.cpp:910:48: error: expected ';' before ',' token
  910 | -> unordered_set<iter-value-type<InputIterator>, Hash,
      |                                                ^
      |                                                ;
p925.cpp:913:27: error: expected ')' before ',' token
  913 | unordered_set(from_range_t, R&&, typename see below::size_type, Allocator)
      |              ~            ^
      |                           )
p925.cpp:917:36: error: expected ')' before ',' token
  917 |          unordered_set(from_range_t, R&&, Allocator)
      |                       ~            ^
      |                                    )
p925.cpp:920:88: error: expected ')' before ',' token
  920 | template<ranges::input_range R, class Hash, class Allocator> unordered_set(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
      |                                                                           ~            ^
      |                                                                                        )
p925.cpp:924:45: error: expected nested-name-specifier before 'see'
  924 | unordered_set(initializer_list<T>, typename see below::size_type, Allocator)
      |                                             ^~~
p925.cpp:924:49: error: expected ',' or '...' before 'below'
  924 | unordered_set(initializer_list<T>, typename see below::size_type, Allocator)
      |                                                 ^~~~~
p925.cpp:927:45: error: expected nested-name-specifier before 'see'
  927 | unordered_set(initializer_list<T>, typename see below::size_type, Hash, Allocator)
      |                                             ^~~
p925.cpp:927:49: error: expected ',' or '...' before 'below'
  927 | unordered_set(initializer_list<T>, typename see below::size_type, Hash, Allocator)
      |                                                 ^~~~~
p925.cpp:932:1: error: ISO C++ forbids declaration of 'unordered_set' with no type [-fpermissive]
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      | ^~~~~~~~~~~~~
p925.cpp: In function 'int pmr::unordered_set()':
p925.cpp:932:19: error: only constructors take member initializers
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                   ^~~~~~~~~~~~~
p925.cpp:932:43: error: 'see' was not declared in this scope
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                                           ^~~
p925.cpp:932:33: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                                 ^~~~~~~~~
      |                                 size_t
p925.cpp:932:57: warning: no return statement in function returning non-void [-Wreturn-type]
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                                                         ^
p925.cpp: At global scope:
p925.cpp:932:68: error: ISO C++ forbids declaration of 'unordered_set' with no type [-fpermissive]
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                                                                    ^~~~~~~~~~~~~
p925.cpp:932:59: error: 'explicit' outside class declaration
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                                                           ^~~~~~~~
p925.cpp:932:82: error: 'int pmr::unordered_set' redeclared as different kind of entity
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                                                                                  ^~~~~~~~~
p925.cpp:932:1: note: previous declaration 'int pmr::unordered_set()'
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      | ^~~~~~~~~~~~~
p925.cpp:932:82: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
  932 | unordered_set() : unordered_set(size_type(see below)) { } explicit unordered_set(size_type n,
      |                                                                                  ^~~~~~~~~
      |                                                                                  size_t
p925.cpp:933:1: error: expected primary-expression before 'const'
  933 | const hasher& hf = hasher(),
      | ^~~~~
p925.cpp:934:1: error: expected primary-expression before 'const'
  934 | const key_equal& eql = key_equal(),
      | ^~~~~
p925.cpp:935:1: error: expected primary-expression before 'const'
  935 | const allocator_type& a = allocator_type());
      | ^~~~~
p925.cpp:938:1: error: 'size_type' has not been declared
  938 | size_type n = see below,
      | ^~~~~~~~~
p925.cpp:938:15: error: 'see' was not declared in this scope
  938 | size_type n = see below,
      |               ^~~
p925.cpp:938:19: error: expected ',' or '...' before 'below'
  938 | size_type n = see below,
      |                   ^~~~~
p925.cpp:941:44: error: expected constructor, destructor, or type conversion before ';' token
  941 | const allocator_type& a = allocator_type());
      |                                            ^
p925.cpp:942:37: error: 'value_type' was not declared in this scope
  942 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |                                     ^~~~~~~~~~
p925.cpp:942:37: error: 'value_type' was not declared in this scope
p925.cpp:942:37: error: 'value_type' was not declared in this scope
p925.cpp:942:37: error: 'value_type' was not declared in this scope
p925.cpp:942:37: error: 'value_type' was not declared in this scope
p925.cpp:942:37: error: 'value_type' was not declared in this scope
p925.cpp:942:10: error: 'container_compatible_range' has not been declared
  942 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp:942:36: error: expected '>' before '<' token
  942 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |                                    ^
p925.cpp:942:70: error: expected constructor, destructor, or type conversion before '(' token
  942 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |                                                                      ^
p925.cpp:947:32: error: 'value_type' was not declared in this scope
  947 | unordered_set(initializer_list<value_type> il, size_type n = see below,
      |                                ^~~~~~~~~~
p925.cpp:947:42: error: template argument 1 is invalid
  947 | unordered_set(initializer_list<value_type> il, size_type n = see below,
      |                                          ^
p925.cpp:947:48: error: 'size_type' has not been declared
  947 | unordered_set(initializer_list<value_type> il, size_type n = see below,
      |                                                ^~~~~~~~~
p925.cpp:947:62: error: 'see' was not declared in this scope
  947 | unordered_set(initializer_list<value_type> il, size_type n = see below,
      |                                                              ^~~
p925.cpp:947:66: error: expected ',' or '...' before 'below'
  947 | unordered_set(initializer_list<value_type> il, size_type n = see below,
      |                                                                  ^~~~~
p925.cpp:950:58: error: expected constructor, destructor, or type conversion before ';' token
  950 |               const allocator_type& a = allocator_type());
      |                                                          ^
p925.cpp:954:12: error: expected nested-name-specifier before 'unordered_set'
  954 |   typename unordered_set<K, H, P, A>::size_type
      |            ^~~~~~~~~~~~~
p925.cpp:954:37: error: expected '(' after template-argument-list
  954 |   typename unordered_set<K, H, P, A>::size_type
      |                                     ^~
p925.cpp:955:2: error: 'unord' was not declared in this scope
  955 | [unord.set.erasure]
      |  ^~~~~
p925.cpp:956:5: error: expected initializer before 'erase_if'
  956 |     erase_if(unordered_set<K, H, P, A>& c, Predicate pred);
      |     ^~~~~~~~
p925.cpp:957:8: error: found ':' in nested-name-specifier, expected '::'
  957 | Effects: Equivalent to:
      |        ^
      |        ::
p925.cpp:957:1: error: 'Effects' does not name a type
  957 | Effects: Equivalent to:
      | ^~~~~~~
p925.cpp:959:8: error: expected unqualified-id before 'for'
  959 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |        ^~~
p925.cpp:959:49: error: 'i' does not name a type
  959 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                                 ^
p925.cpp:959:60: error: expected unqualified-id before ')' token
  959 |        for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                                            ^
p925.cpp:964:8: error: expected unqualified-id before 'return'
  964 |        return original_size - c.size();
      |        ^~~~~~
p925.cpp:987:19: error: 'implementation_defined' does not name a type
  987 | using size_type = implementation_defined ; // see 24.2
      |                   ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:988:25: error: 'implementation_defined' does not name a type
  988 | using difference_type = implementation_defined ; // see 24.2
      |                         ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:989:18: error: 'implementation_defined' does not name a type
  989 | using iterator = implementation_defined ; // see 24.2
      |                  ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:990:24: error: 'implementation_defined' does not name a type
  990 | using const_iterator = implementation_defined ; // see 24.2
      |                        ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:991:25: error: 'implementation_defined' does not name a type
  991 | using local_iterator  = implementation_defined ; // see 24.2
      |                         ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:992:31: error: 'implementation_defined' does not name a type
  992 | using const_local_iterator  = implementation_defined ; // see 24.2
      |                               ^~~~~~~~~~~~~~~~~~~~~~
p925.cpp:993:19: error: 'unspecified' does not name a type
  993 | using node_type = unspecified ;
      |                   ^~~~~~~~~~~
p925.cpp:995:38: error: expected ')' before 'n'
  995 | explicit unordered_multiset(size_type n,
      |                            ~         ^~
      |                                      )
p925.cpp:1001:1: error: 'size_type' has not been declared
 1001 | size_type n = see below,
      | ^~~~~~~~~
p925.cpp:1005:10: error: 'container_compatible_range' has not been declared
 1005 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp:1005:36: error: expected '>' before '<' token
 1005 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |                                    ^
p925.cpp:1005:83: error: expected ')' before ',' token
 1005 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |                                                                      ~            ^
      |                                                                                   )
p925.cpp:1016:1: error: 'size_type' has not been declared
 1016 | size_type n = see_below,
      | ^~~~~~~~~
p925.cpp:1020:29: error: expected ')' before 'n'
 1020 | unordered_multiset(size_type n, const allocator_type& a)
      |                   ~         ^~
      |                             )
p925.cpp:1022:29: error: expected ')' before 'n'
 1022 | unordered_multiset(size_type n, const hasher& hf, const allocator_type& a)
      |                   ~         ^~
      |                             )
p925.cpp:1025:56: error: 'size_type' has not been declared
 1025 |   unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
      |                                                        ^~~~~~~~~
p925.cpp:1028:56: error: 'size_type' has not been declared
 1028 |   unordered_multiset(InputIterator f, InputIterator l, size_type n, const hasher& hf,
      |                                                        ^~~~~~~~~
p925.cpp:1030:64: error: 'container_compatible_range' has not been declared
 1030 | : unordered_multiset(f, l, n, hf, key_equal(), a) { } template<container_compatible_range<value_type> R>
      |                                                                ^~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp:1030:90: error: expected '>' before '<' token
 1030 |  unordered_multiset(f, l, n, hf, key_equal(), a) { } template<container_compatible_range<value_type> R>
      |                                                                                         ^

p925.cpp:1031:34: error: expected ')' before ',' token
 1031 |   unordered_multiset(from_range_t, R&& rg, size_type n, const allocator_type& a)
      |                     ~            ^
      |                                  )
p925.cpp:1034:10: error: 'container' has not been declared
 1034 | template<container-compatible-range<value_type> R> unordered_multiset(from_range_t, R&& rg, size_type n, const hasher& hf,
      |          ^~~~~~~~~
p925.cpp:1034:19: error: expected '>' before '-' token
 1034 | template<container-compatible-range<value_type> R> unordered_multiset(from_range_t, R&& rg, size_type n, const hasher& hf,
      |                   ^
p925.cpp:1034:83: error: expected ')' before ',' token
 1034 | template<container-compatible-range<value_type> R> unordered_multiset(from_range_t, R&& rg, size_type n, const hasher& hf,
      |                                                                      ~            ^
      |                                                                                   )
p925.cpp:1037:53: error: 'size_type' has not been declared
 1037 | unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a)
      |                                                     ^~~~~~~~~
p925.cpp:1039:53: error: 'size_type' has not been declared
 1039 | unordered_multiset(initializer_list<value_type> il, size_type n, const hasher& hf,
      |                                                     ^~~~~~~~~
p925.cpp:1049:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1049 | iterator       begin() noexcept;
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1049:1: error: deduced class type 'iterator' in function return type
 1049 | 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
      |                                  ^~~~~~~~
p925.cpp:1050:1: error: 'const_iterator' does not name a type
 1050 | const_iterator begin() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:1051:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1051 | 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
      |                                  ^~~~~~~~
p925.cpp:1051:1: error: deduced class type 'iterator' in function return type
 1051 | 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
      |                                  ^~~~~~~~
p925.cpp:1052:1: error: 'const_iterator' does not name a type
 1052 | const_iterator end() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:1053:1: error: 'const_iterator' does not name a type
 1053 | const_iterator cbegin() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:1054:1: error: 'const_iterator' does not name a type
 1054 | const_iterator cend() const noexcept;
      | ^~~~~~~~~~~~~~
p925.cpp:1057:1: error: 'size_type' does not name a type; did you mean 'size_t'?
 1057 | size_type size() const noexcept;
      | ^~~~~~~~~
      | size_t
p925.cpp:1058:1: error: 'size_type' does not name a type; did you mean 'size_t'?
 1058 | size_type max_size() const noexcept;
      | ^~~~~~~~~
      | size_t
p925.cpp:1060:25: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1060 | template<class... Args> iterator emplace(Args&&... args);
      |                         ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1060:25: error: deduced class type 'iterator' in function return type
 1060 | template<class... Args> iterator emplace(Args&&... args);
      |                         ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:1061:25: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1061 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj);
      |                         ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1061:47: error: 'const_iterator' has not been declared
 1061 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj);
      |                                               ^~~~~~~~~~~~~~
p925.cpp:1061:25: error: deduced class type 'iterator' in function return type
 1061 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj);
      |                         ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:1061:89: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1061 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj);
      |                                                                                         ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1061:89: error: deduced class type 'iterator' in function return type
 1061 | template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj);
      |                                                                                         ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:1062:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1062 | iterator insert(value_type&& obj);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1062:1: error: deduced class type 'iterator' in function return type
 1062 | iterator insert(value_type&& obj);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:1063:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1063 | iterator insert(const_iterator hint, const value_type& obj);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1063:17: error: 'const_iterator' has not been declared
 1063 | iterator insert(const_iterator hint, const value_type& obj);
      |                 ^~~~~~~~~~~~~~
p925.cpp:1063:1: error: deduced class type 'iterator' in function return type
 1063 | iterator insert(const_iterator hint, const value_type& obj);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:1064:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1064 | iterator insert(const_iterator hint, value_type&& obj);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1064:17: error: 'const_iterator' has not been declared
 1064 | iterator insert(const_iterator hint, value_type&& obj);
      |                 ^~~~~~~~~~~~~~
p925.cpp:1064:1: error: deduced class type 'iterator' in function return type
 1064 | iterator insert(const_iterator hint, value_type&& obj);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:1065:94: error: 'container' has not been declared
 1065 | ate<class InputIterator> void insert(InputIterator first, InputIterator last); template<container-compatible-range<value_type> R>
      |                                                                                         ^~~~~~~~~

p925.cpp:1065:103: error: expected '>' before '-' token
 1065 |  InputIterator> void insert(InputIterator first, InputIterator last); template<container-compatible-range<value_type> R>
      |                                                                                         ^

p925.cpp:1066:21: error: 'R' has not been declared
 1066 |   void insert_range(R&& rg);
      |                     ^
p925.cpp:1068:1: error: 'node_type' does not name a type
 1068 | node_type extract(const_iterator position);
      | ^~~~~~~~~
p925.cpp:1069:1: error: 'node_type' does not name a type
 1069 | node_type extract(const key_type& x);
      | ^~~~~~~~~
p925.cpp:1070:19: error: 'node_type' does not name a type
 1070 | template<class K> node_type extract(K&& x);
      |                   ^~~~~~~~~
p925.cpp:1071:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1071 | iterator insert(node_type&& nh);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1071:17: error: 'node_type' has not been declared
 1071 | iterator insert(node_type&& nh);
      |                 ^~~~~~~~~
p925.cpp:1071:1: error: deduced class type 'iterator' in function return type
 1071 | iterator insert(node_type&& nh);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:1072:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1072 | iterator insert(const_iterator hint, node_type&& nh);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1072:17: error: 'const_iterator' has not been declared
 1072 | iterator insert(const_iterator hint, node_type&& nh);
      |                 ^~~~~~~~~~~~~~
p925.cpp:1072:38: error: 'node_type' has not been declared
 1072 | iterator insert(const_iterator hint, node_type&& nh);
      |                                      ^~~~~~~~~
p925.cpp:1072:1: error: deduced class type 'iterator' in function return type
 1072 | iterator insert(const_iterator hint, node_type&& nh);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:1073:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1073 | iterator  erase(iterator position);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1073:17: error: class template placeholder 'std::iterator' not permitted in this context
 1073 | iterator  erase(iterator position);
      |                 ^~~~~~~~
p925.cpp:1073:17: note: use 'auto' for an abbreviated function template
p925.cpp:1073:1: error: deduced class type 'iterator' in function return type
 1073 | iterator  erase(iterator position);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:1074:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1074 | iterator  erase(const_iterator position);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1074:17: error: 'const_iterator' has not been declared
 1074 | iterator  erase(const_iterator position);
      |                 ^~~~~~~~~~~~~~
p925.cpp:1074:1: error: deduced class type 'iterator' in function return type
 1074 | iterator  erase(const_iterator position);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:1075:1: error: 'size_type' does not name a type; did you mean 'size_t'?
 1075 | size_type erase(const key_type& k);
      | ^~~~~~~~~
      | size_t
p925.cpp:1076:19: error: 'size_type' does not name a type; did you mean 'size_t'?
 1076 | template<class K> size_type erase(K&& x);
      |                   ^~~~~~~~~
      |                   size_t
p925.cpp:1077:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1077 | 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
      |                                  ^~~~~~~~
p925.cpp:1077:17: error: 'const_iterator' has not been declared
 1077 | iterator  erase(const_iterator first, const_iterator last);
      |                 ^~~~~~~~~~~~~~
p925.cpp:1077:39: error: 'const_iterator' has not been declared
 1077 | iterator  erase(const_iterator first, const_iterator last);
      |                                       ^~~~~~~~~~~~~~
p925.cpp:1077:1: error: deduced class type 'iterator' in function return type
 1077 | iterator  erase(const_iterator first, const_iterator last);
      | ^~~~~~~~
/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
      |                                  ^~~~~~~~
p925.cpp:1095:1: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1095 | iterator
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1095:1: error: invalid use of template-name 'std::iterator' without an argument list
 1095 | iterator
      | ^~~~~~~~
p925.cpp:1096:1: error: expected ';' at end of member declaration
 1096 | const_iterator
      | ^~~~~~~~~~~~~~
      |               ;
p925.cpp:1098:3: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1098 |   iterator
      |   ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1099:1: error: expected unqualified-id before 'template'
 1099 | template<class K>
      | ^~~~~~~~
p925.cpp:1101:1: error: ISO C++ forbids declaration of 'find' with no type [-fpermissive]
 1101 | find(const key_type& k) const;
      | ^~~~
p925.cpp:1102:12: error: 'K' does not name a type
 1102 | find(const K& k);
      |            ^
p925.cpp:1102:1: error: ISO C++ forbids declaration of 'find' with no type [-fpermissive]
 1102 | find(const K& k);
      | ^~~~
p925.cpp:1103:3: error: 'const_iterator' does not name a type
 1103 |   const_iterator find(const K& k) const;
      |   ^~~~~~~~~~~~~~
p925.cpp:1104:1: error: 'size_type' does not name a type; did you mean 'size_t'?
 1104 | size_type        count(const key_type& k) const;
      | ^~~~~~~~~
      | size_t
p925.cpp:1106:3: error: 'size_type' does not name a type; did you mean 'size_t'?
 1106 |   size_type      count(const K& k) const;
      |   ^~~~~~~~~
      |   size_t
p925.cpp:1110:8: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1110 |   pair<iterator, iterator>
      |        ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1110:18: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1110 |   pair<iterator, iterator>
      |                  ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1110:26: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
 1110 |   pair<iterator, iterator>
      |                          ^
p925.cpp:1110:26: note:   expected a type, got 'iterator'
p925.cpp:1110:26: error: type/value mismatch at argument 2 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
p925.cpp:1110:26: note:   expected a type, got 'iterator'
p925.cpp:1111:8: error: invalid use of non-static data member 'pmr::std::unordered_multiset<Key, Hash, Pred, Allocator>::const_iterator'
 1111 |   pair<const_iterator, const_iterator>
      |        ^~~~~~~~~~~~~~
p925.cpp:1096:1: note: declared here
 1096 | const_iterator
      | ^~~~~~~~~~~~~~
p925.cpp:1111:24: error: invalid use of non-static data member 'pmr::std::unordered_multiset<Key, Hash, Pred, Allocator>::const_iterator'
 1111 |   pair<const_iterator, const_iterator>
      |                        ^~~~~~~~~~~~~~
p925.cpp:1096:1: note: declared here
 1096 | const_iterator
      | ^~~~~~~~~~~~~~
p925.cpp:1111:38: error: template argument 1 is invalid
 1111 |   pair<const_iterator, const_iterator>
      |                                      ^
p925.cpp:1111:38: error: template argument 2 is invalid
p925.cpp:1115:3: error: 'size_type' does not name a type; did you mean 'size_t'?
 1115 |   size_type max_bucket_count() const noexcept;
      |   ^~~~~~~~~
      |   size_t
p925.cpp:1116:3: error: 'size_type' does not name a type; did you mean 'size_t'?
 1116 |   size_type bucket_size(size_type n) const;
      |   ^~~~~~~~~
      |   size_t
p925.cpp:1117:3: error: 'size_type' does not name a type; did you mean 'size_t'?
 1117 |   size_type bucket(const key_type& k) const;
      |   ^~~~~~~~~
      |   size_t
p925.cpp:1118:3: error: 'local_iterator' does not name a type
 1118 |   local_iterator begin(size_type n);
      |   ^~~~~~~~~~~~~~
p925.cpp:1119:3: error: 'const_local_iterator' does not name a type
 1119 |   const_local_iterator begin(size_type n) const;
      |   ^~~~~~~~~~~~~~~~~~~~
p925.cpp:1120:3: error: 'local_iterator' does not name a type
 1120 |   local_iterator end(size_type n);
      |   ^~~~~~~~~~~~~~
p925.cpp:1121:3: error: 'const_local_iterator' does not name a type
 1121 |   const_local_iterator end(size_type n) const;
      |   ^~~~~~~~~~~~~~~~~~~~
p925.cpp:1122:3: error: 'const_local_iterator' does not name a type
 1122 |   const_local_iterator cbegin(size_type n) const;
      |   ^~~~~~~~~~~~~~~~~~~~
p925.cpp:1123:3: error: 'const_local_iterator' does not name a type
 1123 |   const_local_iterator cend(size_type n) const;
      |   ^~~~~~~~~~~~~~~~~~~~
p925.cpp:1128:15: error: 'size_type' has not been declared
 1128 |   void rehash(size_type n);
      |               ^~~~~~~~~
p925.cpp:1129:16: error: 'size_type' has not been declared
 1129 |   void reserve(size_type n);
      |                ^~~~~~~~~
p925.cpp:1001:15: error: 'see' was not declared in this scope
 1001 | size_type n = see below,
      |               ^~~
p925.cpp:1016:15: error: 'see_below' was not declared in this scope
 1016 | size_type n = see_below,
      |               ^~~~~~~~~
p925.cpp:1132:19: error: 'iter_value_type' was not declared in this scope
 1132 | class Hash = hash<iter_value_type<InputIterator>>,
      |                   ^~~~~~~~~~~~~~~
p925.cpp:1132:48: error: template argument 1 is invalid
 1132 | class Hash = hash<iter_value_type<InputIterator>>,
      |                                                ^~
p925.cpp:1133:23: error: 'iter_value_type' was not declared in this scope
 1133 | class Pred = equal_to<iter_value_type<InputIterator>>,
      |                       ^~~~~~~~~~~~~~~
p925.cpp:1133:52: error: template argument 1 is invalid
 1133 | class Pred = equal_to<iter_value_type<InputIterator>>,
      |                                                    ^~
p925.cpp:1134:29: error: 'iter' was not declared in this scope
 1134 | class Allocator = allocator<iter-value-type<InputIterator>>>
      |                             ^~~~
p925.cpp:1134:34: error: 'value' was not declared in this scope
 1134 | class Allocator = allocator<iter-value-type<InputIterator>>>
      |                                  ^~~~~
p925.cpp:1134:40: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1134 | class Allocator = allocator<iter-value-type<InputIterator>>>
      |                                        ^~~~
      |                                        std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1134:58: error: template argument 1 is invalid
 1134 | class Allocator = allocator<iter-value-type<InputIterator>>>
      |                                                          ^~
p925.cpp:1135:50: error: 'see_below' has not been declared
 1135 | unordered_multiset(InputIterator, InputIterator, see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      |                                                  ^~~~~~~~~
p925.cpp:1135:73: error: 'see_below' was not declared in this scope
 1135 | unordered_multiset(InputIterator, InputIterator, see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      |                                                                         ^~~~~~~~~
p925.cpp:1136:23: error: 'iter' was not declared in this scope
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                       ^~~~
p925.cpp:1136:28: error: 'value' was not declared in this scope
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                            ^~~~~
p925.cpp:1136:34: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                  ^~~~
      |                                  std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1136:52: error: template argument 1 is invalid
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                                    ^
p925.cpp:1136:52: error: template argument 2 is invalid
p925.cpp:1136:52: error: template argument 3 is invalid
p925.cpp:1136:52: error: template argument 4 is invalid
p925.cpp:1136:23: error: 'iter' was not declared in this scope
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                       ^~~~
p925.cpp:1136:28: error: 'value' was not declared in this scope
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                            ^~~~~
p925.cpp:1136:34: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                  ^~~~
      |                                  std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1136:52: error: template argument 1 is invalid
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                                    ^
p925.cpp:1136:52: error: template argument 2 is invalid
p925.cpp:1136:52: error: template argument 3 is invalid
p925.cpp:1136:52: error: template argument 4 is invalid
p925.cpp:1136:23: error: 'iter' was not declared in this scope
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                       ^~~~
p925.cpp:1136:28: error: 'value' was not declared in this scope
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                            ^~~~~
p925.cpp:1136:34: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                  ^~~~
      |                                  std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1136:52: error: template argument 1 is invalid
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                                    ^
p925.cpp:1136:52: error: template argument 2 is invalid
p925.cpp:1136:52: error: template argument 3 is invalid
p925.cpp:1136:52: error: template argument 4 is invalid
p925.cpp:1136:23: error: 'iter' was not declared in this scope
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                       ^~~~
p925.cpp:1136:28: error: 'value' was not declared in this scope
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                            ^~~~~
p925.cpp:1136:34: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                  ^~~~
      |                                  std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1136:52: error: template argument 1 is invalid
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                                    ^
p925.cpp:1136:52: error: template argument 2 is invalid
p925.cpp:1136:52: error: template argument 3 is invalid
p925.cpp:1136:52: error: template argument 4 is invalid
p925.cpp:1136:4: error: invalid template-id
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |    ^~~~~~~~~~~~~~~~~~
p925.cpp:1136:23: error: 'iter' was not declared in this scope
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                       ^~~~
p925.cpp:1136:28: error: 'value' was not declared in this scope
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                            ^~~~~
p925.cpp:1136:34: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                  ^~~~
      |                                  std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1136:52: error: expected primary-expression before '>' token
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                                    ^
p925.cpp:1136:52: error: trailing return type 'unordered_multiset<...auto...>' of deduction guide is not a specialization of 'pmr::std::unordered_multiset<Key, Hash, Pred, Allocator>'
p925.cpp:1136:53: error: expected ';' before ',' token
 1136 | -> unordered_multiset<iter-value-type<InputIterator>, Hash, Pred, Allocator>;
      |                                                     ^
      |                                                     ;
p925.cpp:1141:32: error: expected ')' before ',' token
 1141 | unordered_multiset(from_range_t, R&&, typename see_below::size_type = see_below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      |                   ~            ^
      |                                )
p925.cpp:1143:56: error: 'key_type' does not name a type; did you mean 'key_t'?
 1143 |                                      equal_range(const key_type& k) const;
      |                                                        ^~~~~~~~
      |                                                        key_t
p925.cpp:1143:74: error: expected constructor, destructor, or type conversion before ';' token
 1143 |                                      equal_range(const key_type& k) const;
      |                                                                          ^
p925.cpp:1144:56: error: 'K' does not name a type
 1144 |                                      equal_range(const K& k);
      |                                                        ^
p925.cpp:1144:61: error: expected constructor, destructor, or type conversion before ';' token
 1144 |                                      equal_range(const K& k);
      |                                                             ^
p925.cpp:1145:6: error: 'const_iterator' was not declared in this scope
 1145 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |      ^~~~~~~~~~~~~~
p925.cpp:1145:22: error: 'const_iterator' was not declared in this scope
 1145 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                      ^~~~~~~~~~~~~~
p925.cpp:1145:36: error: template argument 1 is invalid
 1145 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                    ^
p925.cpp:1145:36: error: template argument 2 is invalid
p925.cpp:1145:56: error: 'K' does not name a type
 1145 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                                        ^
p925.cpp:1145:62: error: non-member function 'int pmr::std::equal_range(const int&)' cannot have cv-qualifier
 1145 | pair<const_iterator, const_iterator> equal_range(const K& k) const;
      |                                                              ^~~~~
p925.cpp:1146:8: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1146 |   pair<iterator, iterator>
      |        ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1146:18: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
 1146 |   pair<iterator, iterator>
      |                  ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
  127 |     struct _GLIBCXX17_DEPRECATED iterator
      |                                  ^~~~~~~~
p925.cpp:1146:26: error: type/value mismatch at argument 1 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
 1146 |   pair<iterator, iterator>
      |                          ^
p925.cpp:1146:26: note:   expected a type, got 'iterator'
p925.cpp:1146:26: error: type/value mismatch at argument 2 in template parameter list for 'template<class _T1, class _T2> struct std::pair'
p925.cpp:1146:26: note:   expected a type, got 'iterator'
p925.cpp:1147:1: error: expected unqualified-id before 'template'
 1147 | template<class K>
      | ^~~~~~~~
p925.cpp:1152:50: error: expected nested-name-specifier before 'see'
 1152 | unordered_multiset(initializer_list<T>, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      |                                                  ^~~
p925.cpp:1152:54: error: expected ',' or '...' before 'below'
 1152 | unordered_multiset(initializer_list<T>, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
      |                                                      ^~~~~
p925.cpp:1155:59: error: expected nested-name-specifier before 'see'
 1155 | unordered_multiset(InputIterator, InputIterator, typename see below::size_type, Allocator)
      |                                                           ^~~
p925.cpp:1155:63: error: expected ',' or '...' before 'below'
 1155 | unordered_multiset(InputIterator, InputIterator, typename see below::size_type, Allocator)
      |                                                               ^~~~~
p925.cpp:1156:23: error: 'iter' was not declared in this scope
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                       ^~~~
p925.cpp:1156:28: error: 'value' was not declared in this scope
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                            ^~~~~
p925.cpp:1156:34: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                                  ^~~~
      |                                  std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1156:52: error: template argument 1 is invalid
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                                                    ^
p925.cpp:1156:52: error: template argument 2 is invalid
p925.cpp:1156:52: error: template argument 3 is invalid
p925.cpp:1156:52: error: template argument 4 is invalid
p925.cpp:1156:23: error: 'iter' was not declared in this scope
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                       ^~~~
p925.cpp:1156:28: error: 'value' was not declared in this scope
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                            ^~~~~
p925.cpp:1156:34: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                                  ^~~~
      |                                  std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1156:52: error: template argument 1 is invalid
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                                                    ^
p925.cpp:1156:52: error: template argument 2 is invalid
p925.cpp:1156:52: error: template argument 3 is invalid
p925.cpp:1156:52: error: template argument 4 is invalid
p925.cpp:1156:23: error: 'iter' was not declared in this scope
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                       ^~~~
p925.cpp:1156:28: error: 'value' was not declared in this scope
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                            ^~~~~
p925.cpp:1156:34: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                                  ^~~~
      |                                  std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1156:52: error: template argument 1 is invalid
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                                                    ^
p925.cpp:1156:52: error: template argument 2 is invalid
p925.cpp:1156:52: error: template argument 3 is invalid
p925.cpp:1156:52: error: template argument 4 is invalid
p925.cpp:1156:23: error: 'iter' was not declared in this scope
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                       ^~~~
p925.cpp:1156:28: error: 'value' was not declared in this scope
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                            ^~~~~
p925.cpp:1156:34: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                                  ^~~~
      |                                  std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1156:52: error: template argument 1 is invalid
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                                                    ^
p925.cpp:1156:52: error: template argument 2 is invalid
p925.cpp:1156:52: error: template argument 3 is invalid
p925.cpp:1156:52: error: template argument 4 is invalid
p925.cpp:1156:4: error: invalid template-id
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |    ^~~~~~~~~~~~~~~~~~
p925.cpp:1156:23: error: 'iter' was not declared in this scope
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                       ^~~~
p925.cpp:1156:28: error: 'value' was not declared in this scope
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                            ^~~~~
p925.cpp:1156:34: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                                  ^~~~
      |                                  std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1156:52: error: expected primary-expression before '>' token
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                                                    ^
p925.cpp:1156:52: error: trailing return type 'unordered_multiset<...auto...>' of deduction guide is not a specialization of 'pmr::std::unordered_multiset<Key, Hash, Pred, Allocator>'
p925.cpp:1156:53: error: expected ';' before ',' token
 1156 | -> unordered_multiset<iter-value-type<InputIterator>, hash<iter-value-type <InputIterator>>,
      |                                                     ^
      |                                                     ;
p925.cpp:1158:118: error: expected nested-name-specifier before 'see'
 1158 |  class Hash, class Allocator> unordered_multiset(InputIterator, InputIterator, typename see below::size_type,
      |                                                                                         ^~~

p925.cpp:1158:122: error: expected ',' or '...' before 'below'
 1158 | ss Hash, class Allocator> unordered_multiset(InputIterator, InputIterator, typename see below::size_type,
      |                                                                                         ^~~~~

p925.cpp:1160:23: error: 'iter' was not declared in this scope
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                       ^~~~
p925.cpp:1160:28: error: 'value' was not declared in this scope
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                            ^~~~~
p925.cpp:1160:34: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                                  ^~~~
      |                                  std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1160:52: error: template argument 1 is invalid
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                                                    ^
p925.cpp:1160:52: error: template argument 2 is invalid
p925.cpp:1160:52: error: template argument 3 is invalid
p925.cpp:1160:52: error: template argument 4 is invalid
p925.cpp:1160:23: error: 'iter' was not declared in this scope
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                       ^~~~
p925.cpp:1160:28: error: 'value' was not declared in this scope
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                            ^~~~~
p925.cpp:1160:34: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                                  ^~~~
      |                                  std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1160:52: error: template argument 1 is invalid
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                                                    ^
p925.cpp:1160:52: error: template argument 2 is invalid
p925.cpp:1160:52: error: template argument 3 is invalid
p925.cpp:1160:52: error: template argument 4 is invalid
p925.cpp:1160:23: error: 'iter' was not declared in this scope
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                       ^~~~
p925.cpp:1160:28: error: 'value' was not declared in this scope
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                            ^~~~~
p925.cpp:1160:34: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                                  ^~~~
      |                                  std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1160:52: error: template argument 1 is invalid
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                                                    ^
p925.cpp:1160:52: error: template argument 2 is invalid
p925.cpp:1160:52: error: template argument 3 is invalid
p925.cpp:1160:52: error: template argument 4 is invalid
p925.cpp:1160:23: error: 'iter' was not declared in this scope
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                       ^~~~
p925.cpp:1160:28: error: 'value' was not declared in this scope
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                            ^~~~~
p925.cpp:1160:34: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                                  ^~~~
      |                                  std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1160:52: error: template argument 1 is invalid
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                                                    ^
p925.cpp:1160:52: error: template argument 2 is invalid
p925.cpp:1160:52: error: template argument 3 is invalid
p925.cpp:1160:52: error: template argument 4 is invalid
p925.cpp:1160:4: error: invalid template-id
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |    ^~~~~~~~~~~~~~~~~~
p925.cpp:1160:23: error: 'iter' was not declared in this scope
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                       ^~~~
p925.cpp:1160:28: error: 'value' was not declared in this scope
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                            ^~~~~
p925.cpp:1160:34: error: 'type' was not declared in this scope; did you mean 'std::__cmp_cat::type'?
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                                  ^~~~
      |                                  std::__cmp_cat::type
/usr/local/include/c++/12.1.0/compare:51:11: note: 'std::__cmp_cat::type' declared here
   51 |     using type = signed char;
      |           ^~~~
p925.cpp:1160:52: error: expected primary-expression before '>' token
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                                                    ^
p925.cpp:1160:52: error: trailing return type 'unordered_multiset<...auto...>' of deduction guide is not a specialization of 'pmr::std::unordered_multiset<Key, Hash, Pred, Allocator>'
p925.cpp:1160:53: error: expected ';' before ',' token
 1160 | -> unordered_multiset<iter-value-type<InputIterator>, Hash,
      |                                                     ^
      |                                                     ;
p925.cpp:1163:32: error: expected ')' before ',' token
 1163 | unordered_multiset(from_range_t, R&&, typename see_below::size_type, Allocator)
      |                   ~            ^
      |                                )
p925.cpp:1167:41: error: expected ')' before ',' token
 1167 |          unordered_multiset(from_range_t, R&&, Allocator)
      |                            ~            ^
      |                                         )
p925.cpp:1170:93: error: expected ')' before ',' token
 1170 | late<ranges::input_range R, class Hash, class Allocator> unordered_multiset(from_range_t, R&&, typename see_below::size_type, Hash, Allocator)
      |                                                                            ~            ^
      |                                                                                         )
p925.cpp:1174:50: error: 'see_below' has not been declared
 1174 | unordered_multiset(initializer_list<T>, typename see_below::size_type, Allocator)
      |                                                  ^~~~~~~~~
p925.cpp:1177:50: error: 'see_below' has not been declared
 1177 | unordered_multiset(initializer_list<T>, typename see_below::size_type, Hash, Allocator)
      |                                                  ^~~~~~~~~
p925.cpp:1182:1: error: ISO C++ forbids declaration of 'unordered_multiset' with no type [-fpermissive]
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      | ^~~~~~~~~~~~~~~~~~
p925.cpp: In function 'int pmr::unordered_multiset()':
p925.cpp:1182:24: error: only constructors take member initializers
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                        ^~~~~~~~~~~~~~~~~~
p925.cpp:1182:53: error: 'see_below' was not declared in this scope
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                                                     ^~~~~~~~~
p925.cpp:1182:43: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                                           ^~~~~~~~~
      |                                           size_t
p925.cpp:1182:67: warning: no return statement in function returning non-void [-Wreturn-type]
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                                                                   ^
p925.cpp: At global scope:
p925.cpp:1182:78: error: ISO C++ forbids declaration of 'unordered_multiset' with no type [-fpermissive]
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                                                                              ^~~~~~~~~~~~~~~~~~
p925.cpp:1182:69: error: 'explicit' outside class declaration
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                                                                     ^~~~~~~~
p925.cpp:1182:97: error: 'int pmr::unordered_multiset' redeclared as different kind of entity
 1182 | d_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                                                                                         ^~~~~~~~~

p925.cpp:1182:1: note: previous declaration 'int pmr::unordered_multiset()'
 1182 | unordered_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      | ^~~~~~~~~~~~~~~~~~
p925.cpp:1182:97: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
 1182 | d_multiset() : unordered_multiset(size_type(see_below)) { } explicit unordered_multiset(size_type n,
      |                                                                                         ^~~~~~~~~
      |                                                                                         size_t
p925.cpp:1183:1: error: expected primary-expression before 'const'
 1183 | const hasher& hf = hasher(),
      | ^~~~~
p925.cpp:1184:1: error: expected primary-expression before 'const'
 1184 | const key_equal& eql = key_equal(),
      | ^~~~~
p925.cpp:1185:1: error: expected primary-expression before 'const'
 1185 | const allocator_type& a = allocator_type());
      | ^~~~~
p925.cpp:1188:1: error: 'size_type' has not been declared
 1188 | size_type n = see_below,
      | ^~~~~~~~~
p925.cpp:1188:15: error: 'see_below' was not declared in this scope
 1188 | size_type n = see_below,
      |               ^~~~~~~~~
p925.cpp:1189:7: error: 'hasher' does not name a type
 1189 | const hasher& hf = hasher(),
      |       ^~~~~~
p925.cpp:1189:20: error: there are no arguments to 'hasher' that depend on a template parameter, so a declaration of 'hasher' must be available [-fpermissive]
 1189 | const hasher& hf = hasher(),
      |                    ^~~~~~
p925.cpp:1190:7: error: 'key_equal' does not name a type
 1190 | const key_equal& eql = key_equal(),
      |       ^~~~~~~~~
p925.cpp:1190:24: error: there are no arguments to 'key_equal' that depend on a template parameter, so a declaration of 'key_equal' must be available [-fpermissive]
 1190 | const key_equal& eql = key_equal(),
      |                        ^~~~~~~~~
p925.cpp:1191:7: error: 'allocator_type' does not name a type
 1191 | const allocator_type& a = allocator_type());
      |       ^~~~~~~~~~~~~~
p925.cpp:1191:27: error: there are no arguments to 'allocator_type' that depend on a template parameter, so a declaration of 'allocator_type' must be available [-fpermissive]
 1191 | const allocator_type& a = allocator_type());
      |                           ^~~~~~~~~~~~~~
p925.cpp:1191:44: error: expected constructor, destructor, or type conversion before ';' token
 1191 | const allocator_type& a = allocator_type());
      |                                            ^
p925.cpp:1192:37: error: 'value_type' was not declared in this scope
 1192 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |                                     ^~~~~~~~~~
p925.cpp:1192:37: error: 'value_type' was not declared in this scope
p925.cpp:1192:37: error: 'value_type' was not declared in this scope
p925.cpp:1192:37: error: 'value_type' was not declared in this scope
p925.cpp:1192:37: error: 'value_type' was not declared in this scope
p925.cpp:1192:37: error: 'value_type' was not declared in this scope
p925.cpp:1192:10: error: 'container_compatible_range' has not been declared
 1192 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~
p925.cpp:1192:36: error: expected '>' before '<' token
 1192 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |                                    ^
p925.cpp:1192:70: error: expected constructor, destructor, or type conversion before '(' token
 1192 | template<container_compatible_range<value_type> R> unordered_multiset(from_range_t, R&& rg,
      |                                                                      ^
p925.cpp:1197:37: error: 'value_type' was not declared in this scope
 1197 | unordered_multiset(initializer_list<value_type> il, size_type n = see_below,
      |                                     ^~~~~~~~~~
p925.cpp:1197:47: error: template argument 1 is invalid
 1197 | unordered_multiset(initializer_list<value_type> il, size_type n = see_below,
      |                                               ^
p925.cpp:1197:53: error: 'size_type' has not been declared
 1197 | unordered_multiset(initializer_list<value_type> il, size_type n = see_below,
      |                                                     ^~~~~~~~~
p925.cpp:1197:67: error: 'see_below' was not declared in this scope
 1197 | unordered_multiset(initializer_list<value_type> il, size_type n = see_below,
      |                                                                   ^~~~~~~~~
p925.cpp:1198:26: error: 'hasher' does not name a type
 1198 |                    const hasher& hf = hasher(),
      |                          ^~~~~~
p925.cpp:1198:39: error: 'hasher' was not declared in this scope
 1198 |                    const hasher& hf = hasher(),
      |                                       ^~~~~~
p925.cpp:1199:26: error: 'key_equal' does not name a type
 1199 |                    const key_equal& eql = key_equal(),
      |                          ^~~~~~~~~
p925.cpp:1199:43: error: 'key_equal' was not declared in this scope
 1199 |                    const key_equal& eql = key_equal(),
      |                                           ^~~~~~~~~
p925.cpp:1200:26: error: 'allocator_type' does not name a type
 1200 |                    const allocator_type& a = allocator_type());
      |                          ^~~~~~~~~~~~~~
p925.cpp:1200:46: error: 'allocator_type' was not declared in this scope
 1200 |                    const allocator_type& a = allocator_type());
      |                                              ^~~~~~~~~~~~~~
p925.cpp:1200:63: error: expected constructor, destructor, or type conversion before ';' token
 1200 |                    const allocator_type& a = allocator_type());
      |                                                               ^
p925.cpp:1205:12: error: expected nested-name-specifier before 'unordered_multiset'
 1205 |   typename unordered_multiset<K, H, P, A>::size_type
      |            ^~~~~~~~~~~~~~~~~~
p925.cpp:1205:42: error: expected '(' after template-argument-list
 1205 |   typename unordered_multiset<K, H, P, A>::size_type
      |                                          ^~
p925.cpp:1206:1: error: expected initializer before 'erase_if'
 1206 | erase_if(unordered_multiset<K, H, P, A>& c, Predicate pred);
      | ^~~~~~~~
p925.cpp:1208:25: error: 'c' was not declared in this scope
 1208 |    auto original_size = c.size();
      |                         ^
p925.cpp:1209:4: error: expected unqualified-id before 'for'
 1209 |    for (auto i = c.begin(), last = c.end(); i != last; ) {
      |    ^~~
p925.cpp:1209:45: error: 'i' does not name a type
 1209 |    for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                             ^
p925.cpp:1209:56: error: expected unqualified-id before ')' token
 1209 |    for (auto i = c.begin(), last = c.end(); i != last; ) {
      |                                                        ^
p925.cpp:1214:4: error: expected unqualified-id before 'return'
 1214 |    return original_size - c.size();
      |    ^~~~~~
p925.cpp: In function 'int pmr::main()':
p925.cpp:1217:13: error: 'n4910' was not declared in this scope
 1217 |   cout  <<  n4910 << endl;
      |             ^~~~~
p925.cpp: At global scope:
p925.cpp:1219:2: error: expected '}' at end of input
 1219 | }
      |  ^
p925.cpp:55:15: note: to match this '{'
   55 | namespace pmr {
      |               ^

```

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