• Log in

#include <compare>#include <initializer_list> namespace std{// class template flat_settemplate<class Key,class Compare= less<Key>,class KeyContainer= vector<Key>>class flat_set; struct sorted_unique_t{explicit sorted_unique_t()=default;};inlineconstexpr sorted_unique_t sorted_unique{}; template<class Key,class Compare,class KeyContainer,class Allocator>struct uses_allocator<flat_set<Key, Compare, KeyContainer>, Allocator>; // erasure for flat_settemplate<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); // class template flat_multisettemplate<class Key,class Compare= less<Key>,class KeyContainer= vector<Key>>class flat_multiset; struct sorted_equivalent_t{explicit sorted_equivalent_t()=default;};inlineconstexpr sorted_equivalent_t sorted_equivalent{}; template<class Key,class Compare,class KeyContainer,class Allocator>struct uses_allocator<flat_multiset<Key, Compare, KeyContainer>, Allocator>; // erasure for flat_multisettemplate<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);}

namespace std{template<class Key,class Compare= less<Key>,class KeyContainer= vector<Key>>class flat_set{public:// typesusing key_type= Key;using value_type= Key;using key_compare= Compare;using value_compare= Compare;using reference= value_type&;using const_reference=const value_type&;using size_type=typename KeyContainer::size_type;using difference_type=typename KeyContainer::difference_type;using iterator=/* implementation-defined */;using const_iterator=/* implementation-defined */;using reverse_iterator=std::reverse_iterator<iterator>;using const_reverse_iterator=std::reverse_iterator<const_iterator>;using container_type= KeyContainer; // constructors    flat_set(): flat_set(key_compare()){} explicit flat_set(const key_compare& comp):/*c*/()      ,/*compare*/(comp){} explicit flat_set(container_type cont,const key_compare& comp= key_compare());     flat_set(sorted_unique_t,             container_type cont,const key_compare& comp= key_compare()):/*c*/(std::move(cont))      ,/*compare*/(comp){} template<class InputIter>    flat_set(InputIter first, InputIter last,const key_compare& comp= key_compare()):/*c*/()      ,/*compare*/(comp){      insert(first, last);} template<class InputIter>    flat_set(sorted_unique_t,             InputIter first,             InputIter last,const key_compare& comp= key_compare()):/*c*/(first, last)      ,/*compare*/(comp){} template<container-compatible-range<value_type> R>    flat_set(from_range_t fr, R&& rg): flat_set(fr,std::forward<R>(rg), key_compare()){}template<container-compatible-range<value_type> R>    flat_set(from_range_t, R&& rg,const key_compare& comp): flat_set(comp){      insert_range(std::forward<R>(rg));}     flat_set(initializer_list<value_type> il,const key_compare& comp= key_compare()): flat_set(il.begin(), il.end(), comp){}     flat_set(sorted_unique_t s,             initializer_list<value_type> il,const key_compare& comp= key_compare()): flat_set(s, il.begin(), il.end(), comp){} // constructors with allocators template<class Alloc>explicit flat_set(const Alloc& a);template<class Alloc>    flat_set(const key_compare& comp,const Alloc& a);template<class Alloc>    flat_set(const container_type& cont,const Alloc& a);template<class Alloc>    flat_set(const container_type& cont,const key_compare& comp,const Alloc& a);template<class Alloc>    flat_set(sorted_unique_t,const container_type& cont,const Alloc& a);template<class Alloc>    flat_set(sorted_unique_t,const container_type& cont,const key_compare& comp,const Alloc& a);template<class Alloc>    flat_set(const flat_set&,const Alloc& a);template<class Alloc>    flat_set(flat_set&&,const Alloc& a);template<class InputIter,class Alloc>    flat_set(InputIter first, InputIter last,const Alloc& a);template<class InputIter,class Alloc>    flat_set(InputIter first, InputIter last,const key_compare& comp,const Alloc& a);template<class InputIter,class Alloc>    flat_set(sorted_unique_t, InputIter first, InputIter last,const Alloc& a);template<class InputIter,class Alloc>    flat_set(sorted_unique_t,             InputIter first,             InputIter last,const key_compare& comp,const Alloc& a);template<container-compatible-range<value_type> R,class Alloc>    flat_set(from_range_t, R&& rg,const Alloc& a);template<container-compatible-range<value_type> R,class Alloc>    flat_set(from_range_t, R&& rg,const key_compare& comp,const Alloc& a);template<class Alloc>    flat_set(initializer_list<value_type> il,const Alloc& a);template<class Alloc>    flat_set(initializer_list<value_type> il,const key_compare& comp,const Alloc& a);template<class Alloc>    flat_set(sorted_unique_t, initializer_list<value_type> il,const Alloc& a);template<class Alloc>    flat_set(sorted_unique_t,             initializer_list<value_type> il,const key_compare& comp,const Alloc& a);     flat_set& operator=(initializer_list<value_type>); // iterators    iterator begin()noexcept;    const_iterator begin()constnoexcept;    iterator end()noexcept;    const_iterator end()constnoexcept;     reverse_iterator rbegin()noexcept;    const_reverse_iterator rbegin()constnoexcept;    reverse_iterator rend()noexcept;    const_reverse_iterator rend()constnoexcept;     const_iterator cbegin()constnoexcept;    const_iterator cend()constnoexcept;    const_reverse_iterator crbegin()constnoexcept;    const_reverse_iterator crend()constnoexcept; // capacity[[nodiscard]]bool empty()constnoexcept;    size_type size()constnoexcept;    size_type max_size()constnoexcept; // modifierstemplate<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& x){return emplace(x);}    pair<iterator,bool> insert(value_type&& x){return emplace(std::move(x));}template<class K>    pair<iterator,bool> insert(K&& x);    iterator insert(const_iterator position,const value_type& x){return emplace_hint(position, x);}    iterator insert(const_iterator position, value_type&& x){return emplace_hint(position, std::move(x));}template<class K>    iterator insert(const_iterator hint, K&& x); template<class InputIter>void insert(InputIter first, InputIter last);template<class InputIter>void insert(sorted_unique_t, InputIter first, InputIter last);template<container-compatible-range<value_type> R>void insert_range(R&& rg); void insert(initializer_list<value_type> il){ insert(il.begin(), il.end());}void insert(sorted_unique_t s, initializer_list<value_type> il){      insert(s, il.begin(), il.end());}     container_type extract()&&;void replace(container_type&&);     iterator erase(iterator position);    iterator erase(const_iterator position);    size_type erase(const key_type& x);template<class K>    size_type erase(K&& x);    iterator erase(const_iterator first, const_iterator last); void swap(flat_set& y)noexcept;void clear()noexcept; // observers    key_compare key_comp()const;    value_compare value_comp()const; // set operations    iterator find(const key_type& x);    const_iterator find(const key_type& x)const;template<class K>    iterator find(const K& x);template<class K>    const_iterator find(const K& x)const;     size_type count(const key_type& x)const;template<class K>    size_type count(const K& x)const; bool contains(const key_type& x)const;template<class K>bool contains(const K& x)const;     iterator lower_bound(const key_type& x);    const_iterator lower_bound(const key_type& x)const;template<class K>    iterator lower_bound(const K& x);template<class K>    const_iterator lower_bound(const K& x)const;     iterator upper_bound(const key_type& x);    const_iterator upper_bound(const key_type& x)const;template<class K>    iterator upper_bound(const K& x);template<class K>    const_iterator upper_bound(const K& x)const;     pair<iterator, iterator> equal_range(const key_type& x);    pair<const_iterator, const_iterator> equal_range(const key_type& x)const;template<class K>    pair<iterator, iterator> equal_range(const K& x);template<class K>    pair<const_iterator, const_iterator> equal_range(const K& x)const; friendbool operator==(const flat_set& x,const flat_set& y); friend/*synth-three-way-result*/<value_type> operator<=>(const flat_set& x,const flat_set& y); friendvoid swap(flat_set& x, flat_set& y)noexcept{ x.swap(y);} private:    container_type/*c*/;// exposition only    key_compare/*compare*/;// exposition only}; template<class KeyContainer,class Compare= less<typename KeyContainer::value_type>>  flat_set(KeyContainer, Compare= Compare())-> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;template<class KeyContainer,class Allocator>  flat_set(KeyContainer, Allocator)-> flat_set<typename KeyContainer::value_type,                                                less<typename KeyContainer::value_type>,                                                KeyContainer>;template<class KeyContainer,class Compare,class Allocator>  flat_set(KeyContainer, Compare, Allocator)-> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>; template<class KeyContainer,class Compare= less<typename KeyContainer::value_type>>  flat_set(sorted_unique_t, KeyContainer, Compare= Compare())-> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;template<class KeyContainer,class Allocator>  flat_set(sorted_unique_t, KeyContainer, Allocator)-> flat_set<typename KeyContainer::value_type,                less<typename KeyContainer::value_type>,                KeyContainer>;template<class KeyContainer,class Compare,class Allocator>  flat_set(sorted_unique_t, KeyContainer, Compare, Allocator)-> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>; template<class InputIter,class Compare= less</*iter-value-type*/<InputIter>>>  flat_set(InputIter, InputIter, Compare= Compare())-> flat_set</*iter-value-type*/<InputIter>, Compare>; template<class InputIter,class Compare= less</*iter-value-type*/<InputIter>>>  flat_set(sorted_unique_t, InputIter, InputIter, Compare= Compare())-> flat_set</*iter-value-type*/<InputIter>, Compare>; template<ranges::input_range R,class Compare= less<ranges::range_value_t<R>>,class Allocator= allocator<ranges::range_value_t<R>>>  flat_set(from_range_t, R&&, Compare= Compare(), Allocator= Allocator())-> flat_set<ranges::range_value_t<R>,                Compare,                vector<ranges::range_value_t<R>,/*alloc-rebind*/<Allocator,ranges::range_value_t<R>>>>; template<ranges::input_range R,class Allocator>  flat_set(from_range_t, R&&, Allocator)-> flat_set<ranges::range_value_t<R>,                less<ranges::range_value_t<R>>,                vector<ranges::range_value_t<R>,/*alloc-rebind*/<Allocator,ranges::range_value_t<R>>>>; template<class Key,class Compare= less<Key>>  flat_set(initializer_list<Key>, Compare= Compare())-> flat_set<Key, Compare>; template<class Key,class Compare= less<Key>>  flat_set(sorted_unique_t, initializer_list<Key>, Compare= Compare())-> flat_set<Key, Compare>; template<class Key,class Compare,class KeyContainer,class Allocator>struct uses_allocator<flat_set<Key, Compare, KeyContainer>, Allocator>: bool_constant<uses_allocator_v<KeyContainer, Allocator>>{};}

namespace std{template<class Key,class Compare= less<Key>,class KeyContainer= vector<Key>>class flat_multiset{public:// typesusing key_type= Key;using value_type= Key;using key_compare= Compare;using value_compare= Compare;using reference= value_type&;using const_reference=const value_type&;using size_type=typename KeyContainer::size_type;using difference_type=typename KeyContainer::difference_type;using iterator=/* implementation-defined */;using const_iterator=/* implementation-defined */;using reverse_iterator=std::reverse_iterator<iterator>;using const_reverse_iterator=std::reverse_iterator<const_iterator>;using container_type= KeyContainer; // constructors    flat_multiset(): flat_multiset(key_compare()){} explicit flat_multiset(const key_compare& comp):/*c*/()      ,/*compare*/(comp){} explicit flat_multiset(container_type cont,const key_compare& comp= key_compare());     flat_multiset(sorted_equivalent_t,                  container_type cont,const key_compare& comp= key_compare()):/*c*/(std::move(cont))      ,/*compare*/(comp){} template<class InputIter>    flat_multiset(InputIter first,                  InputIter last,const key_compare& comp= key_compare()):/*c*/()      ,/*compare*/(comp){      insert(first, last);} template<class InputIter>    flat_multiset(sorted_equivalent_t,                  InputIter first,                  InputIter last,const key_compare& comp= key_compare()):/*c*/(first, last)      ,/*compare*/(comp){} template<container-compatible-range<value_type> R>    flat_multiset(from_range_t fr, R&& rg): flat_multiset(fr,std::forward<R>(rg), key_compare()){}template<container-compatible-range<value_type> R>    flat_multiset(from_range_t, R&& rg,const key_compare& comp): flat_multiset(comp){      insert_range(std::forward<R>(rg));}     flat_multiset(initializer_list<value_type> il,const key_compare& comp= key_compare()): flat_multiset(il.begin(), il.end(), comp){}     flat_multiset(sorted_equivalent_t s,                  initializer_list<value_type> il,const key_compare& comp= key_compare()): flat_multiset(s, il.begin(), il.end(), comp){} // constructors with allocators template<class Alloc>explicit flat_multiset(const Alloc& a);template<class Alloc>    flat_multiset(const key_compare& comp,const Alloc& a);template<class Alloc>    flat_multiset(const container_type& cont,const Alloc& a);template<class Alloc>    flat_multiset(const container_type& cont,const key_compare& comp,const Alloc& a);template<class Alloc>    flat_multiset(sorted_equivalent_t,const container_type& cont,const Alloc& a);template<class Alloc>    flat_multiset(sorted_equivalent_t,const container_type& cont,const key_compare& comp,const Alloc& a);template<class Alloc>    flat_multiset(const flat_multiset&,const Alloc& a);template<class Alloc>    flat_multiset(flat_multiset&&,const Alloc& a);template<class InputIter,class Alloc>    flat_multiset(InputIter first, InputIter last,const Alloc& a);template<class InputIter,class Alloc>    flat_multiset(InputIter first,                  InputIter last,const key_compare& comp,const Alloc& a);template<class InputIter,class Alloc>    flat_multiset(sorted_equivalent_t, InputIter first, InputIter last,const Alloc& a);template<class InputIter,class Alloc>    flat_multiset(sorted_equivalent_t,                  InputIter first,                  InputIter last,const key_compare& comp,const Alloc& a);template<container-compatible-range<value_type> R,class Alloc>    flat_multiset(from_range_t, R&& rg,const Alloc& a);template<container-compatible-range<value_type> R,class Alloc>    flat_multiset(from_range_t, R&& rg,const key_compare& comp,const Alloc& a);template<class Alloc>    flat_multiset(initializer_list<value_type> il,const Alloc& a);template<class Alloc>    flat_multiset(initializer_list<value_type> il,const key_compare& comp,const Alloc& a);template<class Alloc>    flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,const Alloc& a);template<class Alloc>    flat_multiset(sorted_equivalent_t,                  initializer_list<value_type> il,const key_compare& comp,const Alloc& a);     flat_multiset& operator=(initializer_list<value_type>); // iterators    iterator begin()noexcept;    const_iterator begin()constnoexcept;    iterator end()noexcept;    const_iterator end()constnoexcept;     reverse_iterator rbegin()noexcept;    const_reverse_iterator rbegin()constnoexcept;    reverse_iterator rend()noexcept;    const_reverse_iterator rend()constnoexcept;     const_iterator cbegin()constnoexcept;    const_iterator cend()constnoexcept;    const_reverse_iterator crbegin()constnoexcept;    const_reverse_iterator crend()constnoexcept; // capacity[[nodiscard]]bool empty()constnoexcept;    size_type size()constnoexcept;    size_type max_size()constnoexcept; // modifierstemplate<class...Args>    iterator emplace(Args&&...args);template<class...Args>    iterator emplace_hint(const_iterator position, Args&&...args);     iterator insert(const value_type& x){return emplace(x);}    iterator insert(value_type&& x){return emplace(std::move(x));}    iterator insert(const_iterator position,const value_type& x){return emplace_hint(position, x);}    iterator insert(const_iterator position, value_type&& x){return emplace_hint(position, std::move(x));} template<class InputIter>void insert(InputIter first, InputIter last);template<class InputIter>void insert(sorted_equivalent_t, InputIter first, InputIter last);template<container-compatible-range<value_type> R>void insert_range(R&& rg); void insert(initializer_list<value_type> il){ insert(il.begin(), il.end());}void insert(sorted_equivalent_t s, initializer_list<value_type> il){      insert(s, il.begin(), il.end());}     container_type extract()&&;void replace(container_type&&);     iterator erase(iterator position);    iterator erase(const_iterator position);    size_type erase(const key_type& x);template<class K>    size_type erase(K&& x);    iterator erase(const_iterator first, const_iterator last); void swap(flat_multiset& y)noexcept;void clear()noexcept; // observers    key_compare key_comp()const;    value_compare value_comp()const; // set operations    iterator find(const key_type& x);    const_iterator find(const key_type& x)const;template<class K>    iterator find(const K& x);template<class K>    const_iterator find(const K& x)const;     size_type count(const key_type& x)const;template<class K>    size_type count(const K& x)const; bool contains(const key_type& x)const;template<class K>bool contains(const K& x)const;     iterator lower_bound(const key_type& x);    const_iterator lower_bound(const key_type& x)const;template<class K>    iterator lower_bound(const K& x);template<class K>    const_iterator lower_bound(const K& x)const;     iterator upper_bound(const key_type& x);    const_iterator upper_bound(const key_type& x)const;template<class K>    iterator upper_bound(const K& x);template<class K>    const_iterator upper_bound(const K& x)const;     pair<iterator, iterator> equal_range(const key_type& x);    pair<const_iterator, const_iterator> equal_range(const key_type& x)const;template<class K>    pair<iterator, iterator> equal_range(const K& x);template<class K>    pair<const_iterator, const_iterator> equal_range(const K& x)const; friendbool operator==(const flat_multiset& x,const flat_multiset& y); friend/*synth-three-way-result*/<value_type> operator<=>(const flat_multiset& x,const flat_multiset& y); friendvoid swap(flat_multiset& x, flat_multiset& y)noexcept{ x.swap(y);} private:    container_type/*c*/;// exposition only    key_compare/*compare*/;// exposition only}; template<class KeyContainer,class Compare= less<typename KeyContainer::value_type>>  flat_multiset(KeyContainer, Compare= Compare())-> flat_multiset<typename KeyContainer::value_type, Compare, KeyContainer>;template<class KeyContainer,class Allocator>  flat_multiset(KeyContainer, Allocator)-> flat_multiset<typename KeyContainer::value_type,                     less<typename KeyContainer::value_type>,                     KeyContainer>;template<class KeyContainer,class Compare,class Allocator>  flat_multiset(KeyContainer, Compare, Allocator)-> flat_multiset<typename KeyContainer::value_type, Compare, KeyContainer>; template<class KeyContainer,class Compare= less<typename KeyContainer::value_type>>  flat_multiset(sorted_equivalent_t, KeyContainer, Compare= Compare())-> flat_multiset<typename KeyContainer::value_type, Compare, KeyContainer>;template<class KeyContainer,class Allocator>  flat_multiset(sorted_equivalent_t, KeyContainer, Allocator)-> flat_multiset<typename KeyContainer::value_type,                     less<typename KeyContainer::value_type>,                     KeyContainer>;template<class KeyContainer,class Compare,class Allocator>  flat_multiset(sorted_equivalent_t, KeyContainer, Compare, Allocator)-> flat_multiset<typename KeyContainer::value_type, Compare, KeyContainer>; template<class InputIter,class Compare= less</*iter-value-type*/<InputIter>>>  flat_multiset(InputIter, InputIter, Compare= Compare())-> flat_multiset</*iter-value-type*/<InputIter>, Compare>; template<class InputIter,class Compare= less</*iter-value-type*/<InputIter>>>  flat_multiset(sorted_equivalent_t, InputIter, InputIter, Compare= Compare())-> flat_multiset</*iter-value-type*/<InputIter>, Compare>; template<ranges::input_range R,class Compare= less<ranges::range_value_t<R>>,class Allocator= allocator<ranges::range_value_t<R>>>  flat_multiset(from_range_t, R&&, Compare= Compare(), Allocator= Allocator())-> flat_multiset<ranges::range_value_t<R>,                     Compare,                     vector<ranges::range_value_t<R>,/*alloc-rebind*/<Allocator,ranges::range_value_t<R>>>>; template<ranges::input_range R,class Allocator>  flat_multiset(from_range_t, R&&, Allocator)-> flat_multiset<ranges::range_value_t<R>,                     less<ranges::range_value_t<R>>,                     vector<ranges::range_value_t<R>,/*alloc-rebind*/<Allocator,ranges::range_value_t<R>>>>; template<class Key,class Compare= less<Key>>  flat_multiset(initializer_list<Key>, Compare= Compare())-> flat_multiset<Key, Compare>; template<class Key,class Compare= less<Key>>  flat_multiset(sorted_equivalent_t, initializer_list<Key>, Compare= Compare())-> flat_multiset<Key, Compare>; template<class Key,class Compare,class KeyContainer,class Allocator>struct uses_allocator<flat_multiset<Key, Compare, KeyContainer>, Allocator>: bool_constant<uses_allocator_v<KeyContainer, Allocator>>{};}