explicit queue(const Container& cont);
explicit queue(Container&& cont);
template<class InputIterator>
queue(InputIterator first, InputIterator last);
template<container-compatible-range<T> R>
queue(from_range_t, R&& rg);
template<class Alloc> explicit queue(const Alloc& a);
template<class Alloc> queue(const container_type& cont, const Alloc& a);
template<class Alloc> queue(container_type&& cont, const Alloc& a);
template<class Alloc> queue(const queue& q, const Alloc& a);
template<class Alloc> queue(queue&& q, const Alloc& a);
template<class InputIterator, class Alloc>
queue(InputIterator first, InputIterator last, const Alloc& alloc);
template<container-compatible-range<T> R, class Alloc>
queue(from_range_t, R&& rg, const Alloc& a);
template<container-compatible-range<T> R>
void push_range(R&& rg);
template<class T, class Container>
bool operator==(const queue<T, Container>& x, const queue<T, Container>& y);
template<class T, class Container>
bool operator!=(const queue<T, Container>& x, const queue<T, Container>& y);
template<class T, class Container>
bool operator< (const queue<T, Container>& x, const queue<T, Container>& y);
template<class T, class Container>
bool operator> (const queue<T, Container>& x, const queue<T, Container>& y);
template<class T, class Container>
bool operator<=(const queue<T, Container>& x, const queue<T, Container>& y);
template<class T, class Container>
bool operator>=(const queue<T, Container>& x,
const queue<T, Container>& y);
template<class T, three_way_comparable Container>
compare_three_way_result_t<Container>
operator<=>(const queue<T, Container>& x, const queue<T, Container>& y);
priority_queue(const Compare& x, const Container& y);
priority_queue(const Compare& x, Container&& y);
template<class InputIterator>
priority_queue(InputIterator first, InputIterator last, const Compare& x = Compare());
template<class InputIterator>
priority_queue(InputIterator first, InputIterator last, const Compare& x, const Container& y);
template<class InputIterator>
priority_queue(InputIterator first, InputIterator last, const Compare& x, Container&& y);
template<container-compatible-range<T> R>
priority_queue(from_range_t, R&& rg, const Compare& x = Compare());
template<class Alloc> explicit priority_queue(const Alloc& a);
template<class Alloc> priority_queue(const Compare& compare, const Alloc& a);
template<class Alloc>
priority_queue(const Compare& compare, const Container& cont, const Alloc& a);
template<class Alloc>
priority_queue(const Compare& compare, Container&& cont, const Alloc& a);
template<class Alloc> priority_queue(const priority_queue& q, const Alloc& a);
template<class Alloc> priority_queue(priority_queue&& q, const Alloc& a);
template<class InputIterator, class Alloc>
priority_queue(InputIterator first, InputIterator last, const Alloc& a);
template<class InputIterator, class Alloc>
priority_queue(InputIterator first, InputIterator last, const Compare& compare, const Alloc& a);
template<class InputIterator, class Alloc>
priority_queue(InputIterator first, InputIterator last, const Compare& compare,
const Container& cont, const Alloc& a);
template<class InputIterator, class Alloc>
priority_queue(InputIterator first, InputIterator last, const Compare& compare, Container&& cont,
const Alloc& a);
template<container-compatible-range<T> R, class Alloc>
priority_queue(from_range_t, R&& rg, const Compare& compare, const Alloc& a);
template<container-compatible-range<T> R, class Alloc>
priority_queue(from_range_t, R&& rg, const Alloc& a);
void push(const value_type& x);
void push(value_type&& x);
template<container-compatible-range<T> R>
void push_range(R&& rg);
template<class... Args> void emplace(Args&&... args);
void pop();
template<class T, class Container, class Compare>
void swap(priority_queue<T, Container, Compare>& x,
priority_queue<T, Container, Compare>& y) noexcept(noexcept(x.swap(y)));
explicit stack(const Container& cont);
explicit stack(Container&& cont);
template<class InputIterator>
stack(InputIterator first, InputIterator last);
template<container-compatible-range<T> R>
stack(from_range_t, R&& rg);
template<class Alloc> explicit stack(const Alloc& a);
template<class Alloc> stack(const container_type& cont, const Alloc& a);
template<class Alloc> stack(container_type&& cont, const Alloc& a);
template<class Alloc> stack(const stack& s, const Alloc& a);
template<class Alloc> stack(stack&& s, const Alloc& a);
template<class InputIterator, class Alloc>
stack(InputIterator first, InputIterator last, const Alloc& alloc);
template<container-compatible-range<T> R, class Alloc>
stack(from_range_t, R&& rg, const Alloc& a);
template<container-compatible-range<T> R>
void push_range(R&& rg);
template<class T, class Container>
bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
template<class T, class Container>
bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);
template<class T, class Container>
bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
template<class T, class Container>
bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
template<class T, class Container>
bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
template<class T, class Container>
bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
template<class T, three_way_comparable Container>
compare_three_way_result_t<Container>
operator<=>(const stack<T, Container>& x, const stack<T, Container>& y);
flat_map(key_container_type key_cont, mapped_container_type mapped_cont,
const key_compare& comp = key_compare());
template<class Allocator>
flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
const Allocator& a);
template<class Allocator>
flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
const key_compare& comp, const Allocator& a);
flat_map(sorted_unique_t, key_container_type key_cont, mapped_container_type mapped_cont,
const key_compare& comp = key_compare());
template<class Allocator>
flat_map(sorted_unique_t s, const key_container_type& key_cont,
const mapped_container_type& mapped_cont, const Allocator& a);
template<class Allocator>
flat_map(sorted_unique_t s, const key_container_type& key_cont,
const mapped_container_type& mapped_cont, const key_compare& comp,
const Allocator& a);
template<class Allocator>
flat_map(const key_compare& comp, const Allocator& a);
template<class Allocator>
explicit flat_map(const Allocator& a);
template<class InputIterator, class Allocator>
flat_map(InputIterator first, InputIterator last, const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_map(InputIterator first, InputIterator last, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_map(from_range_t, R&& rg, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_map(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_map(sorted_unique_t, InputIterator first, InputIterator last,
const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_map(sorted_unique_t, InputIterator first, InputIterator last, const Allocator& a);
template<class Allocator>
flat_map(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_map(initializer_list<value_type> il, const Allocator& a);
template<class Allocator>
flat_map(sorted_unique_t, initializer_list<value_type> il,
const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_map(sorted_unique_t, initializer_list<value_type> il, const Allocator& a);
size_type size() const noexcept;
size_type max_size() const noexcept;
mapped_type& operator[](const key_type& x);
mapped_type& operator[](key_type&& x);
template<class K> mapped_type& operator[](K&& x);
mapped_type& at(const key_type& x);
const mapped_type& at(const key_type& x) const;
template<class K> mapped_type& at(const K& x);
template<class K> const mapped_type& at(const K& x) const;
template<class... Args> pair<iterator, bool> emplace(Args&&... args);
template<class P> pair<iterator, bool> insert(P&& x);
template<class P> iterator insert(const_iterator position, P&& x);
template<class InputIterator>
void insert(InputIterator first, InputIterator last);
template<class InputIterator>
void insert(sorted_unique_t, InputIterator first, InputIterator last);
template<container-compatible-range<value_type> R>
void insert_range(R&& rg);
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 K, class... Args>
pair<iterator, bool> try_emplace(K&& k, Args&&... args);
template<class K, class... Args>
iterator try_emplace(const_iterator hint, K&& 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);
template<class K, class M>
pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
template<class K, class M>
iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
void swap(flat_map& y) noexcept;
containers extract() &&;
void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
class Predicate>
typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type
erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
const key_compare& comp = key_compare());
template<class Allocator>
flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
const Allocator& a);
template<class Allocator>
flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
const key_compare& comp, const Allocator& a);
flat_multimap(sorted_equivalent_t, key_container_type key_cont, mapped_container_type mapped_cont,
const key_compare& comp = key_compare());
template<class Allocator>
flat_multimap(sorted_equivalent_t s, const key_container_type& key_cont,
const mapped_container_type& mapped_cont, const Allocator& a);
template<class Allocator>
flat_multimap(sorted_equivalent_t s, const key_container_type& key_cont,
const mapped_container_type& mapped_cont, const key_compare& comp,
const Allocator& a);
template<class Allocator>
flat_multimap(const key_compare& comp, const Allocator& a);
template<class Allocator>
explicit flat_multimap(const Allocator& a);
template<class InputIterator, class Allocator>
flat_multimap(InputIterator first, InputIterator last, const key_compare& comp,
const Allocator& a);
template<class InputIterator, class Allocator>
flat_multimap(InputIterator first, InputIterator last, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_multimap(from_range_t, R&& rg, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
const Allocator& a);
template<class Allocator>
flat_multimap(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_multimap(initializer_list<value_type> il, const Allocator& a);
template<class Allocator>
flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_multimap(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
class Predicate>
typename flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>::size_type
erase_if(flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
explicit flat_set(container_type cont, const key_compare& comp = key_compare());
template<class Allocator>
flat_set(const container_type& cont, const Allocator& a);
template<class Allocator>
flat_set(const container_type& cont, const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_set(sorted_unique_t s, const container_type& cont, const Allocator& a);
template<class Allocator>
flat_set(sorted_unique_t s, const container_type& cont,
const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_set(const key_compare& comp, const Allocator& a);
template<class Allocator>
explicit flat_set(const Allocator& a);
template<class InputIterator, class Allocator>
flat_set(InputIterator first, InputIterator last, const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_set(InputIterator first, InputIterator last, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_set(from_range_t, R&& rg, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_set(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_set(sorted_unique_t, InputIterator first, InputIterator last,
const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_set(sorted_unique_t, InputIterator first, InputIterator last, const Allocator& a);
template<class Allocator>
flat_set(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_set(initializer_list<value_type> il, const Allocator& a);
template<class Allocator>
flat_set(sorted_unique_t, initializer_list<value_type> il,
const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_set(sorted_unique_t, initializer_list<value_type> il, const Allocator& a);
template<class K> pair<iterator, bool> insert(K&& x);
template<class K> iterator insert(const_iterator hint, K&& x);
template<class InputIterator>
void insert(InputIterator first, InputIterator last);
template<class InputIterator>
void insert(sorted_unique_t, InputIterator first, InputIterator last);
template<container-compatible-range<value_type> R>
void insert_range(R&& rg);
void swap(flat_set& y) noexcept;
container_type extract() &&;
void replace(container_type&& cont);
template<class Key, class Compare, class KeyContainer, class Predicate>
typename flat_set<Key, Compare, KeyContainer>::size_type
erase_if(flat_set<Key, Compare, KeyContainer>& c, Predicate pred);
explicit flat_multiset(container_type cont, const key_compare& comp = key_compare());
template<class Allocator>
flat_multiset(const container_type& cont, const Allocator& a);
template<class Allocator>
flat_multiset(const container_type& cont, const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_multiset(sorted_equivalent_t s, const container_type& cont, const Allocator& a);
template<class Allocator>
flat_multiset(sorted_equivalent_t s, const container_type& cont,
const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_multiset(const key_compare& comp, const Allocator& a);
template<class Allocator>
explicit flat_multiset(const Allocator& a);
template<class InputIterator, class Allocator>
flat_multiset(InputIterator first, InputIterator last,
const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_multiset(InputIterator first, InputIterator last, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_multiset(from_range_t, R&& rg, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_multiset(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last, const Allocator& a);
template<class Allocator>
flat_multiset(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_multiset(initializer_list<value_type> il, const Allocator& a);
template<class Allocator>
flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_multiset(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
template<class... Args> iterator emplace(Args&&... args);
template<class InputIterator>
void insert(InputIterator first, InputIterator last);
template<class InputIterator>
void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
void swap(flat_multiset& y) noexcept;
container_type extract() &&;
void replace(container_type&& cont);
template<class Key, class Compare, class KeyContainer, class Predicate>
typename flat_multiset<Key, Compare, KeyContainer>::size_type
erase_if(flat_multiset<Key, Compare, KeyContainer>& c, Predicate pred);
template<class ParseContext>
constexpr typename ParseContext::iterator
parse(ParseContext& ctx);
template<class FormatContext>
typename FormatContext::iterator
format(maybe-const-adaptor& r, FormatContext& ctx) const;