+ struct auto_ptr_ref
+ {
+ _Tp1* _M_ptr;
+
+ explicit
+ auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
+ } _GLIBCXX_DEPRECATED;
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+ /**
+ * @brief A simple smart pointer providing strict ownership semantics.
+ *
+ * The Standard says:
+ *
+ * An @c auto_ptr owns the object it holds a pointer to. Copying
+ * an @c auto_ptr copies the pointer and transfers ownership to the
+ * destination. If more than one @c auto_ptr owns the same object
+ * at the same time the behavior of the program is undefined.
+ *
+ * The uses of @c auto_ptr include providing temporary
+ * exception-safety for dynamically allocated memory, passing
+ * ownership of dynamically allocated memory to a function, and
+ * returning dynamically allocated memory from a function. @c
+ * auto_ptr does not meet the CopyConstructible and Assignable
+ * requirements for Standard Library container elements and thus
+ * instantiating a Standard Library container with an @c auto_ptr
+ * results in undefined behavior.
+ *
+ * Quoted from [20.4.5]/3.
+ *
+ * Good examples of what can and cannot be done with auto_ptr can
+ * be found in the libstdc++ testsuite.
+ *
+ * _GLIBCXX_RESOLVE_LIB_DEFECTS
+ * 127. auto_ptr<> conversion issues
+ * These resolutions have all been incorporated.
+ */
+ template
+ class auto_ptr
+ {
+ private:
+ _Tp* _M_ptr;
+
+ public:
+ /// The pointed-to type.
+ typedef _Tp element_type;
+
+ /**
+ * @brief An %auto_ptr is usually constructed from a raw pointer.
+ * @param __p A pointer (defaults to NULL).
+ *
+ * This object now @e owns the object pointed to by @a __p.
+ */
+ explicit
+ auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
+
+ /**
+ * @brief An %auto_ptr can be constructed from another %auto_ptr.
+ * @param __a Another %auto_ptr of the same type.
+ *
+ * This object now @e owns the object previously owned by @a __a,
+ * which has given up ownership.
+ */
+ auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
+
+ /**
+ * @brief An %auto_ptr can be constructed from another %auto_ptr.
+ * @param __a Another %auto_ptr of a different but related type.
+ *
+ * A pointer-to-Tp1 must be convertible to a
+ * pointer-to-Tp/element_type.
+ *
+ * This object now @e owns the object previously owned by @a __a,
+ * which has given up ownership.
+ */
+ template
+ auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
+
+ /**
+ * @brief %auto_ptr assignment operator.
+ * @param __a Another %auto_ptr of the same type.
+ *
+ * This object now @e owns the object previously owned by @a __a,
+ * which has given up ownership. The object that this one @e
+ * used to own and track has been deleted.
+ */
+ auto_ptr&
+ operator=(auto_ptr& __a) throw()
+ {
+ reset(__a.release());
+ return *this;
+ }
+
+ /**
+ * @brief %auto_ptr assignment operator.
+ * @param __a Another %auto_ptr of a different but related type.
+ *
+ * A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type.
+ *
+ * This object now @e owns the object previously owned by @a __a,
+ * which has given up ownership. The object that this one @e
+ * used to own and track has been deleted.
+ */
+ template
+ auto_ptr&
+ operator=(auto_ptr<_Tp1>& __a) throw()
+ {
+ reset(__a.release());
+ return *this;
+ }
+
+ /**
+ * When the %auto_ptr goes out of scope, the object it owns is
+ * deleted. If it no longer owns anything (i.e., @c get() is
+ * @c NULL), then this has no effect.
+ *
+ * The C++ standard says there is supposed to be an empty throw
+ * specification here, but omitting it is standard conforming. Its
+ * presence can be detected only if _Tp::~_Tp() throws, but this is
+ * prohibited. [17.4.3.6]/2
+ */
+ ~auto_ptr() { delete _M_ptr; }
+
+ /**
+ * @brief Smart pointer dereferencing.
+ *
+ * If this %auto_ptr no longer owns anything, then this
+ * operation will crash. (For a smart pointer, no longer owns
+ * anything is the same as being a null pointer, and you know
+ * what happens when you dereference one of those...)
+ */
+ element_type&
+ operator*() const throw()
+ {
+ __glibcxx_assert(_M_ptr != 0);
+ return *_M_ptr;
+ }
+
+ /**
+ * @brief Smart pointer dereferencing.
+ *
+ * This returns the pointer itself, which the language then will
+ * automatically cause to be dereferenced.
+ */
+ element_type*
+ operator->() const throw()
+ {
+ __glibcxx_assert(_M_ptr != 0);
+ return _M_ptr;
+ }
+
+ /**
+ * @brief Bypassing the smart pointer.
+ * @return The raw pointer being managed.
+ *
+ * You can get a copy of the pointer that this object owns, for
+ * situations such as passing to a function which only accepts
+ * a raw pointer.
+ *
+ * @note This %auto_ptr still owns the memory.
+ */
+ element_type*
+ get() const throw() { return _M_ptr; }
+
+ /**
+ * @brief Bypassing the smart pointer.
+ * @return The raw pointer being managed.
+ *
+ * You can get a copy of the pointer that this object owns, for
+ * situations such as passing to a function which only accepts
+ * a raw pointer.
+ *
+ * @note This %auto_ptr no longer owns the memory. When this object
+ * goes out of scope, nothing will happen.
+ */
+ element_type*
+ release() throw()
+ {
+ element_type* __tmp = _M_ptr;
+ _M_ptr = 0;
+ return __tmp;
+ }
+
+ /**
+ * @brief Forcibly deletes the managed object.
+ * @param __p A pointer (defaults to NULL).
+ *
+ * This object now @e owns the object pointed to by @a __p. The
+ * previous object has been deleted.
+ */
+ void
+ reset(element_type* __p = 0) throw()
+ {
+ if (__p != _M_ptr)
+ {
+ delete _M_ptr;
+ _M_ptr = __p;
+ }
+ }
+
+ /**
+ * @brief Automatic conversions
+ *
+ * These operations are supposed to convert an %auto_ptr into and from
+ * an auto_ptr_ref automatically as needed. This would allow
+ * constructs such as
+ * @code
+ * auto_ptr func_returning_auto_ptr(.....);
+ * ...
+ * auto_ptr ptr = func_returning_auto_ptr(.....);
+ * @endcode
+ *
+ * But it doesn't work, and won't be fixed. For further details see
+ * http://cplusplus.github.io/LWG/lwg-closed.html#463
+ */
+ auto_ptr(auto_ptr_ref __ref) throw()
+ : _M_ptr(__ref._M_ptr) { }
+
+ auto_ptr&
+ operator=(auto_ptr_ref __ref) throw()
+ {
+ if (__ref._M_ptr != this->get())
+ {
+ delete _M_ptr;
+ _M_ptr = __ref._M_ptr;
+ }
+ return *this;
+ }
+
+ template
+ operator auto_ptr_ref<_Tp1>() throw()
+ { return auto_ptr_ref<_Tp1>(this->release()); }
+
+ template
+ operator auto_ptr<_Tp1>() throw()
+ { return auto_ptr<_Tp1>(this->release()); }
+ } _GLIBCXX_DEPRECATED;
+
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // 541. shared_ptr template assignment and void
+ template<>
+ class auto_ptr
+ {
+ public:
+ typedef void element_type;
+ } _GLIBCXX_DEPRECATED;
+
+#if __cplusplus >= 201103L
+ template<_Lock_policy _Lp>
+ template
+ inline
+ __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp>&& __r)
+ : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get()))
+ { __r.release(); }
+
+ template
+ template
+ inline
+ __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r)
+ : _M_ptr(__r.get()), _M_refcount()
+ {
+ __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
+ static_assert( sizeof(_Tp1) > 0, "incomplete type" );
+ _Tp1* __tmp = __r.get();
+ _M_refcount = __shared_count<_Lp>(std::move(__r));
+ _M_enable_shared_from_this_with(__tmp);
+ }
+
+ template
+ template
+ inline
+ shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r)
+ : __shared_ptr<_Tp>(std::move(__r)) { }
+
+ template
+ template
+ inline
+ unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept
+ : _M_t(__u.release(), deleter_type()) { }
+#endif
+
+#pragma GCC diagnostic pop
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif /* _BACKWARD_AUTO_PTR_H */
diff --git a/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@backward@auto_ptr.h.blob b/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@backward@auto_ptr.h.blob
new file mode 100644
index 0000000..868e378
Binary files /dev/null and b/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@backward@auto_ptr.h.blob differ
diff --git a/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@backward@binders.h b/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@backward@binders.h
new file mode 100644
index 0000000..8c2c00d
--- /dev/null
+++ b/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@backward@binders.h
@@ -0,0 +1,182 @@
+// Functor implementations -*- C++ -*-
+
+// Copyright (C) 2001-2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// .
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ */
+
+/** @file backward/binders.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{functional}
+ */
+
+#ifndef _BACKWARD_BINDERS_H
+#define _BACKWARD_BINDERS_H 1
+
+// Suppress deprecated warning for this file.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ // 20.3.6 binders
+ /** @defgroup binders Binder Classes
+ * @ingroup functors
+ *
+ * Binders turn functions/functors with two arguments into functors
+ * with a single argument, storing an argument to be applied later.
+ * For example, a variable @c B of type @c binder1st is constructed
+ * from a functor @c f and an argument @c x. Later, B's @c
+ * operator() is called with a single argument @c y. The return
+ * value is the value of @c f(x,y). @c B can be @a called with
+ * various arguments (y1, y2, ...) and will in turn call @c
+ * f(x,y1), @c f(x,y2), ...
+ *
+ * The function @c bind1st is provided to save some typing. It takes the
+ * function and an argument as parameters, and returns an instance of
+ * @c binder1st.
+ *
+ * The type @c binder2nd and its creator function @c bind2nd do the same
+ * thing, but the stored argument is passed as the second parameter instead
+ * of the first, e.g., @c bind2nd(std::minus(),1.3) will create a
+ * functor whose @c operator() accepts a floating-point number, subtracts
+ * 1.3 from it, and returns the result. (If @c bind1st had been used,
+ * the functor would perform 1.3 - x instead.
+ *
+ * Creator-wrapper functions like @c bind1st are intended to be used in
+ * calling algorithms. Their return values will be temporary objects.
+ * (The goal is to not require you to type names like
+ * @c std::binder1st> for declaring a variable to hold the
+ * return value from @c bind1st(std::plus(),5).
+ *
+ * These become more useful when combined with the composition functions.
+ *
+ * These functions are deprecated in C++11 and can be replaced by
+ * @c std::bind (or @c std::tr1::bind) which is more powerful and flexible,
+ * supporting functions with any number of arguments. Uses of @c bind1st
+ * can be replaced by @c std::bind(f, x, std::placeholders::_1) and
+ * @c bind2nd by @c std::bind(f, std::placeholders::_1, x).
+ * @{
+ */
+ /// One of the @link binders binder functors@endlink.
+ template
+ class binder1st
+ : public unary_function
+ {
+ protected:
+ _Operation op;
+ typename _Operation::first_argument_type value;
+
+ public:
+ binder1st(const _Operation& __x,
+ const typename _Operation::first_argument_type& __y)
+ : op(__x), value(__y) { }
+
+ typename _Operation::result_type
+ operator()(const typename _Operation::second_argument_type& __x) const
+ { return op(value, __x); }
+
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // 109. Missing binders for non-const sequence elements
+ typename _Operation::result_type
+ operator()(typename _Operation::second_argument_type& __x) const
+ { return op(value, __x); }
+ } _GLIBCXX_DEPRECATED;
+
+ /// One of the @link binders binder functors@endlink.
+ template
+ inline binder1st<_Operation>
+ bind1st(const _Operation& __fn, const _Tp& __x)
+ {
+ typedef typename _Operation::first_argument_type _Arg1_type;
+ return binder1st<_Operation>(__fn, _Arg1_type(__x));
+ }
+
+ /// One of the @link binders binder functors@endlink.
+ template
+ class binder2nd
+ : public unary_function
+ {
+ protected:
+ _Operation op;
+ typename _Operation::second_argument_type value;
+
+ public:
+ binder2nd(const _Operation& __x,
+ const typename _Operation::second_argument_type& __y)
+ : op(__x), value(__y) { }
+
+ typename _Operation::result_type
+ operator()(const typename _Operation::first_argument_type& __x) const
+ { return op(__x, value); }
+
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // 109. Missing binders for non-const sequence elements
+ typename _Operation::result_type
+ operator()(typename _Operation::first_argument_type& __x) const
+ { return op(__x, value); }
+ } _GLIBCXX_DEPRECATED;
+
+ /// One of the @link binders binder functors@endlink.
+ template
+ inline binder2nd<_Operation>
+ bind2nd(const _Operation& __fn, const _Tp& __x)
+ {
+ typedef typename _Operation::second_argument_type _Arg2_type;
+ return binder2nd<_Operation>(__fn, _Arg2_type(__x));
+ }
+ /** @} */
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#pragma GCC diagnostic pop
+
+#endif /* _BACKWARD_BINDERS_H */
diff --git a/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@backward@binders.h.blob b/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@backward@binders.h.blob
new file mode 100644
index 0000000..7d2257d
Binary files /dev/null and b/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@backward@binders.h.blob differ
diff --git a/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@bits@algorithmfwd.h b/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@bits@algorithmfwd.h
new file mode 100644
index 0000000..799d9d5
--- /dev/null
+++ b/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@bits@algorithmfwd.h
@@ -0,0 +1,967 @@
+// Forward declarations -*- C++ -*-
+
+// Copyright (C) 2007-2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// .
+
+/** @file bits/algorithmfwd.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{algorithm}
+ */
+
+#ifndef _GLIBCXX_ALGORITHMFWD_H
+#define _GLIBCXX_ALGORITHMFWD_H 1
+
+#pragma GCC system_header
+
+#include
+#include
+#include
+#if __cplusplus >= 201103L
+#include
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ /*
+ adjacent_find
+ all_of (C++11)
+ any_of (C++11)
+ binary_search
+ clamp (C++17)
+ copy
+ copy_backward
+ copy_if (C++11)
+ copy_n (C++11)
+ count
+ count_if
+ equal
+ equal_range
+ fill
+ fill_n
+ find
+ find_end
+ find_first_of
+ find_if
+ find_if_not (C++11)
+ for_each
+ generate
+ generate_n
+ includes
+ inplace_merge
+ is_heap (C++11)
+ is_heap_until (C++11)
+ is_partitioned (C++11)
+ is_sorted (C++11)
+ is_sorted_until (C++11)
+ iter_swap
+ lexicographical_compare
+ lower_bound
+ make_heap
+ max
+ max_element
+ merge
+ min
+ min_element
+ minmax (C++11)
+ minmax_element (C++11)
+ mismatch
+ next_permutation
+ none_of (C++11)
+ nth_element
+ partial_sort
+ partial_sort_copy
+ partition
+ partition_copy (C++11)
+ partition_point (C++11)
+ pop_heap
+ prev_permutation
+ push_heap
+ random_shuffle
+ remove
+ remove_copy
+ remove_copy_if
+ remove_if
+ replace
+ replace_copy
+ replace_copy_if
+ replace_if
+ reverse
+ reverse_copy
+ rotate
+ rotate_copy
+ search
+ search_n
+ set_difference
+ set_intersection
+ set_symmetric_difference
+ set_union
+ shuffle (C++11)
+ sort
+ sort_heap
+ stable_partition
+ stable_sort
+ swap
+ swap_ranges
+ transform
+ unique
+ unique_copy
+ upper_bound
+ */
+
+ /**
+ * @defgroup algorithms Algorithms
+ *
+ * Components for performing algorithmic operations. Includes
+ * non-modifying sequence, modifying (mutating) sequence, sorting,
+ * searching, merge, partition, heap, set, minima, maxima, and
+ * permutation operations.
+ */
+
+ /**
+ * @defgroup mutating_algorithms Mutating
+ * @ingroup algorithms
+ */
+
+ /**
+ * @defgroup non_mutating_algorithms Non-Mutating
+ * @ingroup algorithms
+ */
+
+ /**
+ * @defgroup sorting_algorithms Sorting
+ * @ingroup algorithms
+ */
+
+ /**
+ * @defgroup set_algorithms Set Operations
+ * @ingroup sorting_algorithms
+ *
+ * These algorithms are common set operations performed on sequences
+ * that are already sorted. The number of comparisons will be
+ * linear.
+ */
+
+ /**
+ * @defgroup binary_search_algorithms Binary Search
+ * @ingroup sorting_algorithms
+ *
+ * These algorithms are variations of a classic binary search, and
+ * all assume that the sequence being searched is already sorted.
+ *
+ * The number of comparisons will be logarithmic (and as few as
+ * possible). The number of steps through the sequence will be
+ * logarithmic for random-access iterators (e.g., pointers), and
+ * linear otherwise.
+ *
+ * The LWG has passed Defect Report 270, which notes: The
+ * proposed resolution reinterprets binary search. Instead of
+ * thinking about searching for a value in a sorted range, we view
+ * that as an important special case of a more general algorithm:
+ * searching for the partition point in a partitioned range. We
+ * also add a guarantee that the old wording did not: we ensure that
+ * the upper bound is no earlier than the lower bound, that the pair
+ * returned by equal_range is a valid range, and that the first part
+ * of that pair is the lower bound.
+ *
+ * The actual effect of the first sentence is that a comparison
+ * functor passed by the user doesn't necessarily need to induce a
+ * strict weak ordering relation. Rather, it partitions the range.
+ */
+
+ // adjacent_find
+
+#if __cplusplus > 201703L
+# define __cpp_lib_constexpr_algorithms 201806L
+#endif
+
+#if __cplusplus >= 201103L
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ all_of(_IIter, _IIter, _Predicate);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ any_of(_IIter, _IIter, _Predicate);
+#endif
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ binary_search(_FIter, _FIter, const _Tp&);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ binary_search(_FIter, _FIter, const _Tp&, _Compare);
+
+#if __cplusplus > 201402L
+ template
+ _GLIBCXX14_CONSTEXPR
+ const _Tp&
+ clamp(const _Tp&, const _Tp&, const _Tp&);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ const _Tp&
+ clamp(const _Tp&, const _Tp&, const _Tp&, _Compare);
+#endif
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ copy(_IIter, _IIter, _OIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _BIter2
+ copy_backward(_BIter1, _BIter1, _BIter2);
+
+#if __cplusplus >= 201103L
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ copy_if(_IIter, _IIter, _OIter, _Predicate);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ copy_n(_IIter, _Size, _OIter);
+#endif
+
+ // count
+ // count_if
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ pair<_FIter, _FIter>
+ equal_range(_FIter, _FIter, const _Tp&);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ pair<_FIter, _FIter>
+ equal_range(_FIter, _FIter, const _Tp&, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ fill(_FIter, _FIter, const _Tp&);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ fill_n(_OIter, _Size, const _Tp&);
+
+ // find
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter1
+ find_end(_FIter1, _FIter1, _FIter2, _FIter2);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter1
+ find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+ // find_first_of
+ // find_if
+
+#if __cplusplus >= 201103L
+ template
+ _GLIBCXX20_CONSTEXPR
+ _IIter
+ find_if_not(_IIter, _IIter, _Predicate);
+#endif
+
+ // for_each
+ // generate
+ // generate_n
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ includes(_IIter1, _IIter1, _IIter2, _IIter2);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
+
+ template
+ void
+ inplace_merge(_BIter, _BIter, _BIter);
+
+ template
+ void
+ inplace_merge(_BIter, _BIter, _BIter, _Compare);
+
+#if __cplusplus >= 201103L
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ is_heap(_RAIter, _RAIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ is_heap(_RAIter, _RAIter, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _RAIter
+ is_heap_until(_RAIter, _RAIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _RAIter
+ is_heap_until(_RAIter, _RAIter, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ is_partitioned(_IIter, _IIter, _Predicate);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ is_permutation(_FIter1, _FIter1, _FIter2);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ is_sorted(_FIter, _FIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ is_sorted(_FIter, _FIter, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ is_sorted_until(_FIter, _FIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ is_sorted_until(_FIter, _FIter, _Compare);
+#endif
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ iter_swap(_FIter1, _FIter2);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ lower_bound(_FIter, _FIter, const _Tp&);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ lower_bound(_FIter, _FIter, const _Tp&, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ make_heap(_RAIter, _RAIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ make_heap(_RAIter, _RAIter, _Compare);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ const _Tp&
+ max(const _Tp&, const _Tp&);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ const _Tp&
+ max(const _Tp&, const _Tp&, _Compare);
+
+ // max_element
+ // merge
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ const _Tp&
+ min(const _Tp&, const _Tp&);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ const _Tp&
+ min(const _Tp&, const _Tp&, _Compare);
+
+ // min_element
+
+#if __cplusplus >= 201103L
+ template
+ _GLIBCXX14_CONSTEXPR
+ pair
+ minmax(const _Tp&, const _Tp&);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ pair
+ minmax(const _Tp&, const _Tp&, _Compare);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ pair<_FIter, _FIter>
+ minmax_element(_FIter, _FIter);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ pair<_FIter, _FIter>
+ minmax_element(_FIter, _FIter, _Compare);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ _Tp
+ min(initializer_list<_Tp>);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ _Tp
+ min(initializer_list<_Tp>, _Compare);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ _Tp
+ max(initializer_list<_Tp>);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ _Tp
+ max(initializer_list<_Tp>, _Compare);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ pair<_Tp, _Tp>
+ minmax(initializer_list<_Tp>);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ pair<_Tp, _Tp>
+ minmax(initializer_list<_Tp>, _Compare);
+#endif
+
+ // mismatch
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ next_permutation(_BIter, _BIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ next_permutation(_BIter, _BIter, _Compare);
+
+#if __cplusplus >= 201103L
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ none_of(_IIter, _IIter, _Predicate);
+#endif
+
+ // nth_element
+ // partial_sort
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _RAIter
+ partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _RAIter
+ partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
+
+ // partition
+
+#if __cplusplus >= 201103L
+ template
+ _GLIBCXX20_CONSTEXPR
+ pair<_OIter1, _OIter2>
+ partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ partition_point(_FIter, _FIter, _Predicate);
+#endif
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ pop_heap(_RAIter, _RAIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ pop_heap(_RAIter, _RAIter, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ prev_permutation(_BIter, _BIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ prev_permutation(_BIter, _BIter, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ push_heap(_RAIter, _RAIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ push_heap(_RAIter, _RAIter, _Compare);
+
+ // random_shuffle
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ remove(_FIter, _FIter, const _Tp&);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ remove_if(_FIter, _FIter, _Predicate);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ remove_copy(_IIter, _IIter, _OIter, const _Tp&);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
+
+ // replace
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
+
+ // replace_if
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ reverse(_BIter, _BIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ reverse_copy(_BIter, _BIter, _OIter);
+
+ inline namespace _V2
+ {
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ rotate(_FIter, _FIter, _FIter);
+ }
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ rotate_copy(_FIter, _FIter, _FIter, _OIter);
+
+ // search
+ // search_n
+ // set_difference
+ // set_intersection
+ // set_symmetric_difference
+ // set_union
+
+#if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
+ template
+ void
+ shuffle(_RAIter, _RAIter, _UGenerator&&);
+#endif
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ sort_heap(_RAIter, _RAIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ sort_heap(_RAIter, _RAIter, _Compare);
+
+ template
+ _BIter
+ stable_partition(_BIter, _BIter, _Predicate);
+
+#if __cplusplus < 201103L
+ // For C++11 swap() is declared in .
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ inline void
+ swap(_Tp& __a, _Tp& __b);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ inline void
+ swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]);
+#endif
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter2
+ swap_ranges(_FIter1, _FIter1, _FIter2);
+
+ // transform
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ unique(_FIter, _FIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ unique(_FIter, _FIter, _BinaryPredicate);
+
+ // unique_copy
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ upper_bound(_FIter, _FIter, const _Tp&);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ upper_bound(_FIter, _FIter, const _Tp&, _Compare);
+
+_GLIBCXX_BEGIN_NAMESPACE_ALGO
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ adjacent_find(_FIter, _FIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ adjacent_find(_FIter, _FIter, _BinaryPredicate);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ typename iterator_traits<_IIter>::difference_type
+ count(_IIter, _IIter, const _Tp&);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ typename iterator_traits<_IIter>::difference_type
+ count_if(_IIter, _IIter, _Predicate);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ equal(_IIter1, _IIter1, _IIter2);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _IIter
+ find(_IIter, _IIter, const _Tp&);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter1
+ find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter1
+ find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _IIter
+ find_if(_IIter, _IIter, _Predicate);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _Funct
+ for_each(_IIter, _IIter, _Funct);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ generate(_FIter, _FIter, _Generator);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ generate_n(_OIter, _Size, _Generator);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ bool
+ lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ _FIter
+ max_element(_FIter, _FIter);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ _FIter
+ max_element(_FIter, _FIter, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ _FIter
+ min_element(_FIter, _FIter);
+
+ template
+ _GLIBCXX14_CONSTEXPR
+ _FIter
+ min_element(_FIter, _FIter, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ pair<_IIter1, _IIter2>
+ mismatch(_IIter1, _IIter1, _IIter2);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ pair<_IIter1, _IIter2>
+ mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ nth_element(_RAIter, _RAIter, _RAIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ nth_element(_RAIter, _RAIter, _RAIter, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ partial_sort(_RAIter, _RAIter, _RAIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _BIter
+ partition(_BIter, _BIter, _Predicate);
+
+ template
+ void
+ random_shuffle(_RAIter, _RAIter);
+
+ template
+ void
+ random_shuffle(_RAIter, _RAIter,
+#if __cplusplus >= 201103L
+ _Generator&&);
+#else
+ _Generator&);
+#endif
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ replace(_FIter, _FIter, const _Tp&, const _Tp&);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ replace_if(_FIter, _FIter, _Predicate, const _Tp&);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter1
+ search(_FIter1, _FIter1, _FIter2, _FIter2);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter1
+ search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ search_n(_FIter, _FIter, _Size, const _Tp&);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _FIter
+ search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
+ _OIter, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ sort(_RAIter, _RAIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ void
+ sort(_RAIter, _RAIter, _Compare);
+
+ template
+ void
+ stable_sort(_RAIter, _RAIter);
+
+ template
+ void
+ stable_sort(_RAIter, _RAIter, _Compare);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ transform(_IIter, _IIter, _OIter, _UnaryOperation);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ unique_copy(_IIter, _IIter, _OIter);
+
+ template
+ _GLIBCXX20_CONSTEXPR
+ _OIter
+ unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
+
+_GLIBCXX_END_NAMESPACE_ALGO
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#ifdef _GLIBCXX_PARALLEL
+# include
+#endif
+
+#endif
+
diff --git a/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@bits@algorithmfwd.h.blob b/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@bits@algorithmfwd.h.blob
new file mode 100644
index 0000000..98fd7c5
Binary files /dev/null and b/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@bits@algorithmfwd.h.blob differ
diff --git a/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@bits@alloc_traits.h b/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@bits@alloc_traits.h
new file mode 100644
index 0000000..86d8ed2
--- /dev/null
+++ b/.ccls-cache/@@home@ado@git@ssp/@usr@include@c++@10@bits@alloc_traits.h
@@ -0,0 +1,743 @@
+// Allocator traits -*- C++ -*-
+
+// Copyright (C) 2011-2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// .
+
+/** @file bits/alloc_traits.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _ALLOC_TRAITS_H
+#define _ALLOC_TRAITS_H 1
+
+#include
+#include
+#if __cplusplus >= 201103L
+# include
+# include
+# include
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+#if __cplusplus >= 201103L
+#define __cpp_lib_allocator_traits_is_always_equal 201411
+
+ struct __allocator_traits_base
+ {
+ template
+ struct __rebind : __replace_first_arg<_Tp, _Up> { };
+
+ template
+ struct __rebind<_Tp, _Up,
+ __void_t::other>>
+ { using type = typename _Tp::template rebind<_Up>::other; };
+
+ protected:
+ template
+ using __pointer = typename _Tp::pointer;
+ template
+ using __c_pointer = typename _Tp::const_pointer;
+ template
+ using __v_pointer = typename _Tp::void_pointer;
+ template
+ using __cv_pointer = typename _Tp::const_void_pointer;
+ template
+ using __pocca = typename _Tp::propagate_on_container_copy_assignment;
+ template
+ using __pocma = typename _Tp::propagate_on_container_move_assignment;
+ template
+ using __pocs = typename _Tp::propagate_on_container_swap;
+ template
+ using __equal = typename _Tp::is_always_equal;
+ };
+
+ template
+ using __alloc_rebind
+ = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type;
+
+ /**
+ * @brief Uniform interface to all allocator types.
+ * @ingroup allocators
+ */
+ template
+ struct allocator_traits : __allocator_traits_base
+ {
+ /// The allocator type
+ typedef _Alloc allocator_type;
+ /// The allocated type
+ typedef typename _Alloc::value_type value_type;
+
+ /**
+ * @brief The allocator's pointer type.
+ *
+ * @c Alloc::pointer if that type exists, otherwise @c value_type*
+ */
+ using pointer = __detected_or_t;
+
+ private:
+ // Select _Func<_Alloc> or pointer_traits::rebind<_Tp>
+ template class _Func, typename _Tp, typename = void>
+ struct _Ptr
+ {
+ using type = typename pointer_traits::template rebind<_Tp>;
+ };
+
+ template class _Func, typename _Tp>
+ struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>>
+ {
+ using type = _Func<_Alloc>;
+ };
+
+ // Select _A2::difference_type or pointer_traits<_Ptr>::difference_type
+ template
+ struct _Diff
+ { using type = typename pointer_traits<_PtrT>::difference_type; };
+
+ template
+ struct _Diff<_A2, _PtrT, __void_t