• Log in

namespace std{// invoketemplate<class F,class...Args>constexpr invoke_result_t<F, Args...> invoke(F&& f, Args&&...args)noexcept(is_nothrow_invocable_v<F, Args...>);template<class R,class F,class...Args>constexpr R invoke_r(F&& f, Args&&...args)noexcept(is_nothrow_invocable_r_v<R, F, Args...>); // reference_wrappertemplate<class T>class reference_wrapper; template<class T>constexpr reference_wrapper<T> ref(T&)noexcept;template<class T>constexpr reference_wrapper<const T> cref(const T&)noexcept;template<class T>void ref(const T&&)= delete;template<class T>void cref(const T&&)= delete; template<class T>constexpr reference_wrapper<T> ref(reference_wrapper<T>)noexcept;template<class T>constexpr reference_wrapper<const T> cref(reference_wrapper<T>)noexcept; template<class T>struct unwrap_reference;template<class T>using unwrap_reference_t=typename unwrap_reference<T>::type;template<class T>struct unwrap_ref_decay;template<class T>using unwrap_ref_decay_t=typename unwrap_ref_decay<T>::type; // common_reference related specializationstemplate<class R,class T,template<class>class RQual,template<class>class TQual>    requires/* see below */struct basic_common_reference<R, T, RQual, TQual>; template<class T,class R,template<class>class TQual,template<class>class RQual>    requires/* see below */struct basic_common_reference<T, R, TQual, RQual>; // arithmetic operationstemplate<class T=void>struct plus;template<class T=void>struct minus;template<class T=void>struct multiplies;template<class T=void>struct divides;template<class T=void>struct modulus;template<class T=void>struct negate;template<>struct plus<void>;template<>struct minus<void>;template<>struct multiplies<void>;template<>struct divides<void>;template<>struct modulus<void>;template<>struct negate<void>; // comparisonstemplate<class T=void>struct equal_to;template<class T=void>struct not_equal_to;template<class T=void>struct greater;template<class T=void>struct less;template<class T=void>struct greater_equal;template<class T=void>struct less_equal;template<>struct equal_to<void>;template<>struct not_equal_to<void>;template<>struct greater<void>;template<>struct less<void>;template<>struct greater_equal<void>;template<>struct less_equal<void>; // logical operationstemplate<class T=void>struct logical_and;template<class T=void>struct logical_or;template<class T=void>struct logical_not;template<>struct logical_and<void>;template<>struct logical_or<void>;template<>struct logical_not<void>; // bitwise operationstemplate<class T=void>struct bit_and;template<class T=void>struct bit_or;template<class T=void>struct bit_xor;template<class T=void>struct bit_not;template<>struct bit_and<void>;template<>struct bit_or<void>;template<>struct bit_xor<void>;template<>struct bit_not<void>; // identitystruct identity; // function template not_fntemplate<class F>constexpr/* unspecified */ not_fn(F&& f); // function templates bind_front and bind_backtemplate<class F,class...Args>constexpr/* unspecified */ bind_front(F&&, Args&&...);template<class F,class...Args>constexpr/* unspecified */ bind_back(F&&, Args&&...); // bindtemplate<class T>struct is_bind_expression;template<class T>inlineconstexprbool is_bind_expression_v= is_bind_expression<T>::value; template<class T>struct is_placeholder;template<class T>inlineconstexprint is_placeholder_v= is_placeholder<T>::value; template<class F,class...BoundArgs>constexpr/* unspecified */ bind(F&&, BoundArgs&&...);template<class R,class F,class...BoundArgs>constexpr/* unspecified */ bind(F&&, BoundArgs&&...); namespace placeholders{// M is the implementation-defined number of placeholders/* see description */ _1;/* see description */ _2;               .               .               ./* see description */ _M;} // member function adaptorstemplate<class R,class T>constexpr/* unspecified */ mem_fn(R T::*)noexcept; // polymorphic function wrappersclass bad_function_call; template<class>class function;// not definedtemplate<class R,class...ArgTypes>class function<R(ArgTypes...)>; template<class R,class...ArgTypes>void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&)noexcept; template<class R,class...ArgTypes>bool operator==(const function<R(ArgTypes...)>&, nullptr_t)noexcept; // move-only wrappertemplate<class...>class move_only_function;// not defined template<class R,class...ArgTypes>class move_only_function<R(ArgTypes...)/*cv ref*/noexcept(/*noex*/)>; // copyable wrappertemplate<class...>class copyable_function;// not defined template<class R,class...ArgTypes>class copyable_function<R(ArgTypes...)/*cv ref*/noexcept(/*noex*/)>; // non-owning wrappertemplate<class...>class function_ref;// not defined template<class R,class...ArgTypes>class function_ref<R(ArgTypes...)/*cv*/noexcept(/*noex*/)>; // searcherstemplate<class ForwardIter,class BinaryPredicate= equal_to<>>class default_searcher; template<class RandomAccessIter,class Hash= hash<typename iterator_traits<RandomAccessIter>::value_type>,class BinaryPredicate= equal_to<>>class boyer_moore_searcher; template<class RandomAccessIter,class Hash= hash<typename iterator_traits<RandomAccessIter>::value_type>,class BinaryPredicate= equal_to<>>class boyer_moore_horspool_searcher; // hash function primary templatetemplate<class T>struct hash; // concept-constrained comparisonsstruct compare_three_way;namespace ranges{struct equal_to;struct not_equal_to;struct greater;struct less;struct greater_equal;struct less_equal;} // exposition onlytemplate<class Fn,class...Args>    concept/*callable*/=      requires(Fn&& fn, Args&&...args){std::forward<Fn>(fn)(std::forward<Args>(args)...);}; // exposition onlytemplate<class Fn,class...Args>    concept/*nothrow-callable*/=/*callable*/<Fn, Args...>&&      requires(Fn&& fn, Args&&...args){{std::forward<Fn>(fn)(std::forward<Args>(args)...)}noexcept;}; // exposition onlytemplate<class Fn,class...Args>using/*call-result-t*/= decltype(std::declval<Fn>()(std::declval<Args>()...)); // exposition onlytemplate<constauto& T>using/*decayed-typeof*/= decltype(auto(T));}

namespace std{template<class T>class reference_wrapper{public:// typesusing type= T; // construct/copy/destroytemplate<class U>constexpr reference_wrapper(U&&)noexcept(/* see below */);constexpr reference_wrapper(const reference_wrapper& x)noexcept; // assignmentconstexpr reference_wrapper& operator=(const reference_wrapper& x)noexcept; // accessconstexpr operator T&()constnoexcept;constexpr T& get()constnoexcept; // invocationtemplate<class...ArgTypes>constexpr invoke_result_t<T&, ArgTypes...> operator()(ArgTypes&&...)constnoexcept(is_nothrow_invocable_v<T&, ArgTypes...>); // comparisonfriendconstexprbool operator==(reference_wrapper, reference_wrapper);friendconstexprbool operator==(reference_wrapper,const T&);friendconstexprbool operator==(reference_wrapper, reference_wrapper<const T>); friendconstexprauto operator<=>(reference_wrapper, reference_wrapper);friendconstexprauto operator<=>(reference_wrapper,const T&);friendconstexprauto operator<=>(reference_wrapper, reference_wrapper<const T>);};// deduction guidestemplate<class T>    reference_wrapper(T&)-> reference_wrapper<T>;}

namespace std{template<class T>struct unwrap_reference;}

namespace std{template<class T>struct unwrap_ref_decay;}

namespace std{template<class T=void>struct plus{constexpr T operator()(const T& x,const T& y)const;}; template<>struct plus<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)+std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct minus{constexpr T operator()(const T& x,const T& y)const;}; template<>struct minus<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)-std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct multiplies{constexpr T operator()(const T& x,const T& y)const;}; template<>struct multiplies<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)*std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct divides{constexpr T operator()(const T& x,const T& y)const;}; template<>struct divides<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)/std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct modulus{constexpr T operator()(const T& x,const T& y)const;}; template<>struct modulus<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)%std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct negate{constexpr T operator()(const T& x)const;}; template<>struct negate<void>{template<class T>constexprauto operator()(T&& t)const-> decltype(-std::forward<T>(t)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct equal_to{constexprbool operator()(const T& x,const T& y)const;}; template<>struct equal_to<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)==std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct not_equal_to{constexprbool operator()(const T& x,const T& y)const;}; template<>struct not_equal_to<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)!=std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct greater{constexprbool operator()(const T& x,const T& y)const;}; template<>struct greater<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)>std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct less{constexprbool operator()(const T& x,const T& y)const;}; template<>struct less<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)<std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct greater_equal{constexprbool operator()(const T& x,const T& y)const;}; template<>struct greater_equal<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)>=std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct less_equal{constexprbool operator()(const T& x,const T& y)const;}; template<>struct less_equal<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)<=std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{struct compare_three_way{template<class T,class U>constexprauto operator()(T&& t, U&& u)const; using is_transparent=/* unspecified */;};}

namespace std::ranges{struct equal_to{template<class T,class U>constexprbool operator()(T&& t, U&& u)const; using is_transparent=/* unspecified */;};}

namespace std::ranges{struct not_equal_to{template<class T,class U>constexprbool operator()(T&& t, U&& u)const; using is_transparent=/* unspecified */;};}

namespace std::ranges{struct greater{template<class T,class U>constexprbool operator()(T&& t, U&& u)const; using is_transparent=/* unspecified */;};}

namespace std::ranges{struct less{template<class T,class U>constexprbool operator()(T&& t, U&& u)const; using is_transparent=/* unspecified */;};}

namespace std::ranges{struct greater_equal{template<class T,class U>constexprbool operator()(T&& t, U&& u)const; using is_transparent=/* unspecified */;};}

namespace std::ranges{struct less_equal{template<class T,class U>constexprbool operator()(T&& t, U&& u)const; using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct logical_and{constexprbool operator()(const T& x,const T& y)const;}; template<>struct logical_and<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)&&std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct logical_or{constexprbool operator()(const T& x,const T& y)const;}; template<>struct logical_or<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)||std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct logical_not{constexprbool operator()(const T& x)const;}; template<>struct logical_not<void>{template<class T>constexprauto operator()(T&& t)const-> decltype(!std::forward<T>(t)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct bit_and{constexpr T operator()(const T& x,const T& y)const;}; template<>struct bit_and<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)&std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct bit_or{constexpr T operator()(const T& x,const T& y)const;}; template<>struct bit_or<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)|std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct bit_xor{constexpr T operator()(const T& x,const T& y)const;}; template<>struct bit_xor<void>{template<class T,class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)^std::forward<U>(u)); using is_transparent=/* unspecified */;};}

namespace std{template<class T=void>struct bit_not{constexpr T operator()(const T& x)const;}; template<>struct bit_not<void>{template<class T>constexprauto operator()(T&& t)const-> decltype(~std::forward<T>(t)); using is_transparent=/* unspecified */;};}

namespace std{struct identity{template<class T>constexpr T&& operator()(T&& t)constnoexcept; using is_transparent=/* unspecified */;};}

namespace std{template<class T>struct is_bind_expression;}

namespace std{template<class T>struct is_placeholder;}

namespace std{class bad_function_call:public exception{public:// see [exception] for the specification of the special member functionsconstchar* what()constnoexcept override;};}

namespace std{template<class>class function;// not defined template<class R,class...ArgTypes>class function<R(ArgTypes...)>{public:using result_type= R; // construct/copy/destroy    function()noexcept;    function(nullptr_t)noexcept;    function(const function&);    function(function&&)noexcept;template<class F> function(F);     function& operator=(const function&);    function& operator=(function&&);    function& operator=(nullptr_t)noexcept;template<class F> function& operator=(F&&);template<class F> function& operator=(reference_wrapper<F>)noexcept;     ~function(); // function modifiersvoid swap(function&)noexcept; // function capacityexplicit operatorbool()constnoexcept; // function invocation    R operator()(ArgTypes...)const; // function target accessconst type_info& target_type()constnoexcept;template<class T>       T* target()noexcept;template<class T>const T* target()constnoexcept;}; template<class R,class...ArgTypes>    function(R(*)(ArgTypes...))-> function<R(ArgTypes...)>; template<class F> function(F)-> function</* see description */>; // null pointer comparison functionstemplate<class R,class...ArgTypes>bool operator==(const function<R(ArgTypes...)>&, nullptr_t)noexcept; // specialized algorithmstemplate<class R,class...ArgTypes>void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&)noexcept;}

namespace std{template<class...S>class move_only_function;// not defined template<class R,class...ArgTypes>class move_only_function<R(ArgTypes...)/*cv-ref*/noexcept(/*noex*/)>{public:using result_type= R; // construct/move/destroy    move_only_function()noexcept;    move_only_function(nullptr_t)noexcept;    move_only_function(move_only_function&&)noexcept;template<class F> move_only_function(F&&); template<class T,class...Args>explicit move_only_function(in_place_type_t<T>, Args&&...);template<class T,class U,class...Args>explicit move_only_function(in_place_type_t<T>, initializer_list<U>, Args&&...);     move_only_function& operator=(move_only_function&&);    move_only_function& operator=(nullptr_t)noexcept;template<class F> move_only_function& operator=(F&&);     ~move_only_function(); // invocationexplicit operatorbool()constnoexcept;     R operator()(ArgTypes...)/*cv-ref*/noexcept(/*noex*/); // utilityvoid swap(move_only_function&)noexcept; friendvoid swap(move_only_function&, move_only_function&)noexcept; friendbool operator==(const move_only_function&, nullptr_t)noexcept; private:// exposition-onlytemplate<class VT>staticconstexprbool/*is-callable-from*/=/* see description */;};}

namespace std{template<class...S>class copyable_function;// not defined template<class R,class...ArgTypes>class copyable_function<R(ArgTypes...)/*cv-ref*/noexcept(/*noex*/)>{public:using result_type= R; // construct/move/destroy    copyable_function()noexcept;    copyable_function(nullptr_t)noexcept;    copyable_function(const copyable_function&);    copyable_function(copyable_function&&)noexcept;template<class F> copyable_function(F&&); template<class T,class...Args>explicit copyable_function(in_place_type_t<T>, Args&&...);template<class T,class U,class...Args>explicit copyable_function(in_place_type_t<T>, initializer_list<U>, Args&&...);     copyable_function& operator=(const copyable_function&);    copyable_function& operator=(copyable_function&&);    copyable_function& operator=(nullptr_t)noexcept;template<class F> copyable_function& operator=(F&&);     ~copyable_function(); // invocationexplicit operatorbool()constnoexcept;     R operator()(ArgTypes...)/*cv-ref*/noexcept(/*noex*/); // utilityvoid swap(copyable_function&)noexcept; friendvoid swap(copyable_function&, copyable_function&)noexcept; friendbool operator==(const copyable_function&, nullptr_t)noexcept; private:// exposition-onlytemplate<class VT>staticconstexprbool/*is-callable-from*/=/* see description */;};}

namespace std{template<class...S>class function_ref;// not defined template<class R,class...ArgTypes>class function_ref<R(ArgTypes...)/*cv*/noexcept(/*noex*/)>{public:// constructors and assignment operatorstemplate<class F> function_ref(F*)noexcept;template<class F>constexpr function_ref(F&&)noexcept;template<auto f>constexpr function_ref(nontype_t<f>)noexcept;template<auto f,class U>constexpr function_ref(nontype_t<f>, U&&)noexcept;template<auto f,class T>constexpr function_ref(nontype_t<f>,/*cv*/ T*)noexcept; constexpr function_ref(const function_ref&)noexcept=default;constexpr function_ref& operator=(const function_ref&)noexcept=default;template<class T> function_ref& operator=(T)= delete; // invocation    R operator()(ArgTypes...)/*cv*/noexcept(/*noex*/); private:// exposition-onlytemplate<class...T>staticconstexprbool/*is-invocable-using*/=/* see description */;     R(*thunk-ptr)(BoundEntityType, ArgTypes&&...)noexcept(/*noex*/);// exposition-only    BoundEntityType bound-entity;// exposition-only};// deduction guidestemplate<class F>    function_ref(F*)-> function_ref<F>;template<auto f>    function_ref(nontype_t<f>)-> function_ref</* see description */>;template<auto f,class T>    function_ref(nontype_t<f>, T&&)-> function_ref</* see description */>;}

namespace std{template<class ForwardIter1,class BinaryPredicate= equal_to<>>class default_searcher{public:constexpr default_searcher(ForwardIter1 pat_first, ForwardIter1 pat_last,                                 BinaryPredicate pred= BinaryPredicate()); template<class ForwardIter2>constexpr pair<ForwardIter2, ForwardIter2>          operator()(ForwardIter2 first, ForwardIter2 last)const; private:      ForwardIter1 pat_first_;// exposition only      ForwardIter1 pat_last_;// exposition only      BinaryPredicate pred_;// exposition only};}

namespace std{template<class RandomAccessIter1,class Hash= hash<typename iterator_traits<RandomAccessIter1>::value_type>,class BinaryPredicate= equal_to<>>class boyer_moore_searcher{public:      boyer_moore_searcher(RandomAccessIter1 pat_first,                           RandomAccessIter1 pat_last,                           Hash hf= Hash(),                           BinaryPredicate pred= BinaryPredicate()); template<class RandomAccessIter2>        pair<RandomAccessIter2, RandomAccessIter2>          operator()(RandomAccessIter2 first, RandomAccessIter2 last)const; private:      RandomAccessIter1 pat_first_;// exposition only      RandomAccessIter1 pat_last_;// exposition only      Hash hash_;// exposition only      BinaryPredicate pred_;// exposition only};}

namespace std{template<class RandomAccessIter1,class Hash= hash<typename iterator_traits<RandomAccessIter1>::value_type>,class BinaryPredicate= equal_to<>>class boyer_moore_horspool_searcher{public:      boyer_moore_horspool_searcher(RandomAccessIter1 pat_first,                                    RandomAccessIter1 pat_last,                                    Hash hf= Hash(),                                    BinaryPredicate pred= BinaryPredicate()); template<class RandomAccessIter2>        pair<RandomAccessIter2, RandomAccessIter2>          operator()(RandomAccessIter2 first, RandomAccessIter2 last)const; private:      RandomAccessIter1 pat_first_;// exposition only      RandomAccessIter1 pat_last_;// exposition only      Hash hash_;// exposition only      BinaryPredicate pred_;// exposition only};}