Lines Matching defs:std
145 namespace std
155 namespace std
189 namespace std
2641 namespace std
2735 namespace std
2761 using std::rethrow_exception;
2778 friend exception_ptr std::current_exception() noexcept;
2779 friend void std::rethrow_exception(exception_ptr);
2820 const class std::type_info*
2870 { return std::make_exception_ptr<_Ex>(__ex); }
2895 namespace std __attribute__ ((__visibility__ ("default")))
2920 namespace std
2930 namespace std __attribute__ ((__visibility__ ("default")))
3144 template<typename _Tp, std::size_t _Size>
3343 struct __is_null_pointer_helper<std::nullptr_t>
4251 : public integral_constant<std::size_t, __alignof__(_Tp)> { };
4256 : public integral_constant<std::size_t, 0> { };
4258 template<typename _Tp, std::size_t _Size>
4260 : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
4264 : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
4269 : public integral_constant<std::size_t, 0> { };
4271 template<typename _Tp, unsigned _Uint, std::size_t _Size>
4273 : public integral_constant<std::size_t,
4280 : public integral_constant<std::size_t,
4316 typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
4678 template<typename _Tp, std::size_t _Size>
4691 template<typename _Tp, std::size_t _Size>
4750 template<std::size_t _Len>
4760 template<std::size_t _Len, std::size_t _Align =
4897 (true ? std::declval<_Tp>()
4898 : std::declval<_Up>())>::type> _S_test(int);
4999 (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
5018 ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
5037 std::declval<_Tp1>().*std::declval<_Fp>()
5056 (*std::declval<_Tp1>()).*std::declval<_Fp>()
5181 std::declval<_Fn>()(std::declval<_Args>()...)
5299 using std::swap;
5304 = decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
5315 noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
5352 namespace std __attribute__ ((__visibility__ ("default")))
5357 forward(typename std::remove_reference<_Tp>::type& __t) noexcept
5368 forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
5370 static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
5381 constexpr typename std::remove_reference<_Tp>::type&&
5383 { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
5395 { return std::move(__x); }
5400 { return std::__addressof(__r); }
5407 _Tp __old_val = std::move(__obj);
5408 __obj = std::forward<_Up>(__new_val);
5416 namespace std __attribute__ ((__visibility__ ("default")))
5435 _Tp __tmp = std::move(__a);
5436 __a = std::move(__b);
5437 __b = std::move(__tmp);
5469 namespace std
5496 std::terminate();
5524 throw _Nested_exception<_Up>{std::forward<_Tp>(__t)};
5530 { throw std::forward<_Tp>(__t); }
5546 std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{});
5575 { std::__rethrow_if_nested_impl(std::__addressof(__ex)); }
5592 namespace std
5651 void* operator new(std::size_t)
5653 void* operator new[](std::size_t)
5665 void* operator new(std::size_t, const std::nothrow_t&) noexcept
5667 void* operator new[](std::size_t, const std::nothrow_t&) noexcept
5669 void operator delete(void*, const std::nothrow_t&) noexcept
5671 void operator delete[](void*, const std::nothrow_t&) noexcept
5674 inline void* operator new(std::size_t, void* __p) noexcept
5676 inline void* operator new[](std::size_t, void* __p) noexcept
6807 namespace std __attribute__ ((__visibility__ ("default")))
6904 namespace std
7228 namespace std __attribute__ ((__visibility__ ("default")))
7507 void* operator new(size_t size) throw(std::bad_alloc)
7513 void* operator new(size_t size, const std::nothrow_t&) throw()
7519 void* operator new[](size_t size) throw(std::bad_alloc)
7525 void* operator new[](size_t size, const std::nothrow_t&) throw()
7537 void operator delete(void* ptr, const std::nothrow_t&) throw()
7549 void operator delete[](void* ptr, const std::nothrow_t&) throw()
9627 using std::abort;
9628 using std::atexit;
9629 using std::exit;
9632 using std::at_quick_exit;
9635 using std::quick_exit;
9640 using std::div_t;
9641 using std::ldiv_t;
9643 using std::abs;
9644 using std::atof;
9645 using std::atoi;
9646 using std::atol;
9647 using std::bsearch;
9648 using std::calloc;
9649 using std::div;
9650 using std::free;
9651 using std::getenv;
9652 using std::labs;
9653 using std::ldiv;
9654 using std::malloc;
9656 using std::mblen;
9657 using std::mbstowcs;
9658 using std::mbtowc;
9660 using std::qsort;
9661 using std::rand;
9662 using std::realloc;
9663 using std::srand;
9664 using std::strtod;
9665 using std::strtol;
9666 using std::strtoul;
9667 using std::system;
9669 using std::wcstombs;
9670 using std::wctomb;
12063 namespace std __attribute__ ((__visibility__ ("default")))
12167 namespace std __attribute__ ((__visibility__ ("default")))
12209 __distance(std::_List_iterator<_Tp>,
12210 std::_List_iterator<_Tp>,
12215 __distance(std::_List_const_iterator<_Tp>,
12216 std::_List_const_iterator<_Tp>,
12224 return std::__distance(__first, __last,
12225 std::__iterator_category(__first));
12272 std::__advance(__i, __d, std::__iterator_category(__i));
12285 std::advance(__x, __n);
12297 std::advance(__x, -__n);
12313 namespace std __attribute__ ((__visibility__ ("default")))
12664 typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
12707 typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
12758 __is_null_pointer(std::nullptr_t)
12763 template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
12820 namespace std __attribute__ ((__visibility__ ("default")))
12924 { return std::addressof(__r); }
12935 namespace std __attribute__ ((__visibility__ ("default")))
13272 : container(std::__addressof(__x)) { }
13284 container->push_back(std::move(__value));
13323 : container(std::__addressof(__x)) { }
13335 container->push_front(std::move(__value));
13378 : container(std::__addressof(__x)), iter(__i) {}
13391 iter = container->insert(iter, std::move(__value));
13429 using std::iterator_traits;
13430 using std::iterator;
13458 (std::__are_same<_Iter, typename _Container::pointer>::__value),
13640 namespace std __attribute__ ((__visibility__ ("default")))
13654 namespace std __attribute__ ((__visibility__ ("default")))
13756 { return std::move(_M_current[__n]); }
13920 namespace std __attribute__ ((__visibility__ ("default")))
13939 namespace std __attribute__ ((__visibility__ ("default")))
13999 namespace std
14004 namespace std __attribute__ ((__visibility__ ("default")))
14124 namespace std
14131 namespace std
14134 using std::wcstof;
14137 using std::vfwscanf;
14140 using std::vswscanf;
14143 using std::vwscanf;
14147 using std::wcstold;
14148 using std::wcstoll;
14149 using std::wcstoull;
14154 namespace std __attribute__ ((__visibility__ ("default")))
14286 namespace std __attribute__ ((__visibility__ ("default")))
14438 namespace std __attribute__ ((__visibility__ ("default")))
14546 static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);
14550 static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
14551 static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
14568 : public __conditional_type<std::__is_integer<_Value>::__value,
14578 namespace std __attribute__ ((__visibility__ ("default")))
14590 template<std::size_t...>
14775 : first(std::forward<_U1>(__x)), second(__y) { }
14782 : first(std::forward<_U1>(__x)), second(__y) { }
14789 : first(__x), second(std::forward<_U2>(__y)) { }
14796 : first(__x), second(std::forward<_U2>(__y)) { }
14805 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
14814 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
14824 : first(std::forward<_U1>(__p.first)),
14825 second(std::forward<_U2>(__p.second)) { }
14834 : first(std::forward<_U1>(__p.first)),
14835 second(std::forward<_U2>(__p.second)) { }
14865 first = std::forward<first_type>(__p.first);
14866 second = std::forward<second_type>(__p.second);
14887 first = std::forward<_U1>(__p.first);
14888 second = std::forward<_U2>(__p.second);
14897 using std::swap;
14903 template<typename... _Args1, std::size_t... _Indexes1,
14904 typename... _Args2, std::size_t... _Indexes2>
14965 return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
14976 namespace std
14986 using namespace std::__debug;
15164 typename std::iterator_traits<_Iterator1>::reference _M_ref;
15226 typename std::iterator_traits<_Iterator1>::reference _M_ref;
15267 namespace std __attribute__ ((__visibility__ ("default")))
15292 std::iter_swap(__first1, __first2);
15379 *__result = std::move(*__first);
15414 *__result = std::move(*__first);
15456 return std::__copy_move<_IsMove, __simple,
15493 return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
15494 std::__niter_base(__last),
15495 std::__niter_base(__result)));
15508 return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
15509 (std::__miter_base(__first), std::__miter_base(__last),
15523 return std::__copy_move_a2<true>(std::__miter_base(__first),
15524 std::__miter_base(__last), __result);
15554 *--__result = std::move(*--__last);
15584 *--__result = std::move(*--__last);
15623 return std::__copy_move_backward<_IsMove, __simple,
15633 return _BI2(std::__copy_move_backward_a<_IsMove>
15634 (std::__niter_base(__first), std::__niter_base(__last),
15635 std::__niter_base(__result)));
15650 return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
15651 (std::__miter_base(__first), std::__miter_base(__last),
15667 return std::__copy_move_backward_a2<true>(std::__miter_base(__first),
15668 std::__miter_base(__last),
15718 std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
15750 std::__fill_a(__first, __first + __n, __c);
15761 return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
15803 return std::__equal<__simple>::equal(__first1, __last1, __first2);
15849 typedef std::__lc_rai<_Category1, _Category2> __rai_type;
15876 return std::__lexicographical_compare_impl(__first1, __last1,
15891 if (const size_t __len = std::min(__len1, __len2))
15912 return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
15924 _DistanceType __len = std::distance(__first, __last);
15930 std::advance(__middle, __half);
15954 return std::__lower_bound(__first, __last, __val,
15996 return std::__equal_aux(std::__niter_base(__first1),
15997 std::__niter_base(__last1),
15998 std::__niter_base(__first2));
16036 auto __d1 = std::distance(__first1, __last1);
16037 auto __d2 = std::distance(__first2, __last2);
16040 return std::equal(__first1, __last1, __first2);
16067 auto __d1 = std::distance(__first1, __last1);
16068 auto __d2 = std::distance(__first2, __last2);
16071 return std::equal(__first1, __last1, __first2,
16091 return std::__lexicographical_compare_aux(std::__niter_base(__first1),
16092 std::__niter_base(__last1),
16093 std::__niter_base(__first2),
16094 std::__niter_base(__last2));
16108 return std::__lexicographical_compare_impl
16140 return std::__mismatch(__first1, __last1, __first2,
16155 return std::__mismatch(__first1, __last1, __first2,
16191 return std::__mismatch(__first1, __last1, __first2, __last2,
16208 return std::__mismatch(__first1, __last1, __first2, __last2,
16234 typedef std::streampos pos_type;
16235 typedef std::streamoff off_type;
16236 typedef std::mbstate_t state_type;
16261 compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
16263 static std::size_t
16267 find(const char_type* __s, std::size_t __n, const char_type& __a);
16270 move(char_type* __s1, const char_type* __s2, std::size_t __n);
16273 copy(char_type* __s1, const char_type* __s2, std::size_t __n);
16276 assign(char_type* __s, std::size_t __n, char_type __a);
16302 compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
16304 for (std::size_t __i = 0; __i < __n; ++__i)
16313 std::size_t
16317 std::size_t __i = 0;
16326 find(const char_type* __s, std::size_t __n, const char_type& __a)
16328 for (std::size_t __i = 0; __i < __n; ++__i)
16337 move(char_type* __s1, const char_type* __s2, std::size_t __n)
16346 copy(char_type* __s1, const char_type* __s2, std::size_t __n)
16349 std::copy(__s2, __s2 + __n, __s1);
16356 assign(char_type* __s, std::size_t __n, char_type __a)
16359 std::fill_n(__s, __n, __a);
16366 namespace std __attribute__ ((__visibility__ ("default")))
16567 namespace std
16607 namespace std __attribute__ ((__visibility__ ("default")))
16929 namespace std
16952 namespace std __attribute__ ((__visibility__ ("default")))
17099 namespace std
17122 namespace std
17128 namespace std __attribute__ ((__visibility__ ("default")))
18835 using std::size_t;
18836 using std::ptrdiff_t;
18857 typedef std::true_type propagate_on_container_move_assignment;
18871 { return std::__addressof(__x); }
18875 { return std::__addressof(__x); }
18883 std::__throw_bad_alloc();
18901 { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
18924 namespace std
18932 namespace std __attribute__ ((__visibility__ ("default")))
18959 { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
19141 namespace std __attribute__ ((__visibility__ ("default")))
19237 namespace std __attribute__ ((__visibility__ ("default")))
19358 noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
19359 -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
19360 { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
19373 noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
19374 -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
19375 { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
19388 noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
19389 -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
19390 { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
19403 noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
19404 -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
19405 { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
19418 noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
19419 -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
19420 { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }
19433 noexcept(noexcept(-std::forward<_Tp>(__t)))
19434 -> decltype(-std::forward<_Tp>(__t))
19435 { return -std::forward<_Tp>(__t); }
19528 noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
19529 -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
19530 { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
19543 noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
19544 -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
19545 { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
19558 noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
19559 -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
19560 { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
19573 noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
19574 -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
19575 { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
19588 noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
19589 -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
19590 { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
19603 noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
19604 -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
19605 { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
19659 noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
19660 -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
19661 { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
19674 noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
19675 -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
19676 { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
19689 noexcept(noexcept(!std::forward<_Tp>(__t)))
19690 -> decltype(!std::forward<_Tp>(__t))
19691 { return !std::forward<_Tp>(__t); }
19758 noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
19759 -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
19760 { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
19772 noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
19773 -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
19774 { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
19786 noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
19787 -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
19788 { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
19800 noexcept(noexcept(~std::forward<_Tp>(__t)))
19801 -> decltype(~std::forward<_Tp>(__t))
19802 { return ~std::forward<_Tp>(__t); }
20158 namespace std __attribute__ ((__visibility__ ("default")))
20254 namespace std
20316 namespace std __attribute__ ((__visibility__ ("default")))
20395 cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont)))
20396 -> decltype(std::begin(__cont))
20397 { return std::begin(__cont); }
20406 cend(const _Container& __cont) noexcept(noexcept(std::end(__cont)))
20407 -> decltype(std::end(__cont))
20408 { return std::end(__cont); }
20497 crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont))
20498 { return std::rbegin(__cont); }
20507 crend(const _Container& __cont) -> decltype(std::rend(__cont))
20508 { return std::rend(__cont); }
20523 namespace std __attribute__ ((__visibility__ ("default")))
20688 typename = decltype(std::declval<_Alloc2*>()->construct(
20689 std::declval<_Tp*>(), std::declval<_Args>()...))>
20705 { __a.construct(__p, std::forward<_Args>(__args)...); }
20712 { ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); }
20768 -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
20769 { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
20805 using difference_type = std::ptrdiff_t;
20808 using size_type = std::size_t;
20843 { __a.construct(__p, std::forward<_Args>(__args)...); }
20897 { __one = std::move(__two); }
20914 using std::swap;
20936 = decltype(_Traits::construct(std::declval<_Alloc&>(),
20937 std::declval<_Up*>(),
20938 std::declval<const _Up&>()))>
20980 : std::allocator_traits<_Alloc>
20985 typedef std::allocator_traits<_Alloc> _Base_type;
21003 = std::__and_<std::is_same<pointer, _Ptr>,
21004 std::__not_<std::is_pointer<_Ptr>>>;
21009 static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
21012 _Base_type::construct(__a, std::addressof(*__p),
21013 std::forward<_Args>(__args)...);
21018 static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
21020 { _Base_type::destroy(__a, std::addressof(*__p)); }
21026 { std::__alloc_on_swap(__a, __b); }
21058 namespace std __attribute__ ((__visibility__ ("default")))
21086 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
21087 typedef std::reverse_iterator<iterator> reverse_iterator;
21136 return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
21146 return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);
21187 std::__false_type)
21197 _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
21208 typedef typename std::__is_integer<_InIterator>::__type _Integral;
21216 std::input_iterator_tag);
21223 std::forward_iterator_tag);
21425 : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
21484 typename = std::_RequireInputIter<_InputIterator>>
21517 std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
21552 std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());
21956 typename = std::_RequireInputIter<_InputIterator>>
21996 return *this = std::move(__str);
22025 typename = std::_RequireInputIter<_InputIterator>>
22053 typename = std::_RequireInputIter<_InputIterator>>
22212 typename = std::_RequireInputIter<_InputIterator>>
22221 std::__false_type());
22450 const size_type __len = std::min(__size, __osize);
22546 { return std::move(__lhs.append(__rhs)); }
22552 { return std::move(__rhs.insert(0, __lhs)); }
22562 return __cond ? std::move(__rhs.insert(0, __lhs))
22563 : std::move(__lhs.append(__rhs));
22570 { return std::move(__rhs.insert(0, __lhs)); }
22576 { return std::move(__rhs.insert(0, 1, __lhs)); }
22582 { return std::move(__lhs.append(__rhs)); }
22588 { return std::move(__lhs.append(1, __rhs)); }
22603 && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
22820 { return std::getline(__is, __str, __is.widen('\n')); }
22828 { return std::getline(__is, __str, __delim); }
22835 { return std::getline(__is, __str); }
22881 namespace std
22945 namespace std
23001 const char* __name, const _CharT* __str, std::size_t* __idx,
23017 std::__throw_invalid_argument(__name);
23019 || (std::__are_same<_Ret, int>::__value
23022 std::__throw_out_of_range(__name);
23035 __to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*,
23036 __builtin_va_list), std::size_t __n,
23058 namespace std __attribute__ ((__visibility__ ("default")))
23067 { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
23072 { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
23077 { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
23082 { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
23087 { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
23093 { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
23097 { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
23101 { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
23110 { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(int),
23115 { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
23121 { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(long),
23126 { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
23132 { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
23138 { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
23147 return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
23156 return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
23165 return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
23173 { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
23178 { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
23183 { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
23188 { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
23193 { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
23199 { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
23203 { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
23207 { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
23213 { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
23218 { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
23224 { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
23229 { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
23235 { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
23241 { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
23250 return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
23259 return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
23268 return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
23291 namespace std
23314 namespace std __attribute__ ((__visibility__ ("default")))
23453 return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;
23465 return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;
23485 struct __is_fast_hash : public std::true_type
23489 struct __is_fast_hash<hash<long double>> : public std::false_type
23496 namespace std __attribute__ ((__visibility__ ("default")))
23510 { return std::_Hash_impl::hash(__s.data(), __s.length()); }
23514 struct __is_fast_hash<hash<string>> : std::false_type
23525 { return std::_Hash_impl::hash(__s.data(),
23530 struct __is_fast_hash<hash<wstring>> : std::false_type
23543 { return std::_Hash_impl::hash(__s.data(),
23548 struct __is_fast_hash<hash<u16string>> : std::false_type
23558 { return std::_Hash_impl::hash(__s.data(),
23563 struct __is_fast_hash<hash<u32string>> : std::false_type
23609 namespace std __attribute__ ((__visibility__ ("default")))
23701 std::__throw_length_error(("basic_string::_M_create"));
23728 std::input_iterator_tag)
23771 std::forward_iterator_tag)
23775 std::__throw_logic_error(("basic_string::" "_M_construct null not valid"));
23778 size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));
23945 std::__false_type)
24129 __pos = std::min(size_type(__size - __n), __pos);
24266 const size_type __len = std::min(__n, __osize);
24283 const size_type __len = std::min(__n1, __n2);
24299 const size_type __len = std::min(__size, __osize);
24315 const size_type __len = std::min(__n1, __osize);
24331 const size_type __len = std::min(__n1, __n2);
24514 namespace std __attribute__ ((__visibility__ ("default")))
24563 locale(const std::string& __s) : locale(__s.c_str()) { }
24565 locale(const locale& __base, const std::string& __s, category __cat)
25020 namespace std __attribute__ ((__visibility__ ("default")))
25065 typedef std::collate<_CharT> __collate_type;
25276 namespace std __attribute__ ((__visibility__ ("default")))
25425 namespace std __attribute__ ((__visibility__ ("default")))
25440 __cow_string(const std::string&);
25608 namespace std __attribute__ ((__visibility__ ("default")))
25890 class system_error : public std::runtime_error
25929 namespace std __attribute__ ((__visibility__ ("default")))
25942 const size_t __tmp = std::_Hash_impl::hash(__e._M_value);
25943 return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp);
25952 namespace std __attribute__ ((__visibility__ ("default")))
26264 typedef std::streampos streampos;
26265 typedef std::streamoff streamoff;
26724 namespace std __attribute__ ((__visibility__ ("default")))
27080 std::swap(_M_in_beg, __sb._M_in_beg);
27081 std::swap(_M_in_cur, __sb._M_in_cur);
27082 std::swap(_M_in_end, __sb._M_in_end);
27083 std::swap(_M_out_beg, __sb._M_out_beg);
27084 std::swap(_M_out_cur, __sb._M_out_cur);
27085 std::swap(_M_out_end, __sb._M_out_end);
27086 std::swap(_M_buf_locale, __sb._M_buf_locale);
27093 std::basic_streambuf<_CharT, _Traits>::
27097 std::basic_streambuf<_CharT, _Traits>&
27098 std::basic_streambuf<_CharT, _Traits>::
27121 namespace std __attribute__ ((__visibility__ ("default")))
27137 const streamsize __len = std::min(__buf_len, __remaining);
27171 const streamsize __len = std::min(__buf_len, __remaining);
27481 namespace std
27514 namespace std __attribute__ ((__visibility__ ("default")))
27558 namespace std __attribute__ ((__visibility__ ("default")))
27925 namespace std __attribute__ ((__visibility__ ("default")))
28478 namespace std __attribute__ ((__visibility__ ("default")))
28520 namespace std __attribute__ ((__visibility__ ("default")))
29190 namespace std __attribute__ ((__visibility__ ("default")))
29508 if (!std::__verify_grouping(__lc->_M_grouping,
29706 if (!std::__verify_grouping(__lc->_M_grouping,
29844 std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
29859 std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
29874 std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
29972 _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
30063 return std::__write(__s, __cs, __len);
30077 _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
30125 __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
30128 __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
30137 __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
30140 __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
30200 return std::__write(__s, __ws, __len);
30239 __s = std::__write(__s, __name, __len);
30240 __s = std::__write(__s, __ps, __plen);
30244 __s = std::__write(__s, __ps, __plen);
30245 __s = std::__write(__s, __name, __len);
30250 __s = std::__write(__s, __name, __len);
30464 namespace std __attribute__ ((__visibility__ ("default")))
30739 std::swap(_M_tie, __rhs._M_tie);
30740 std::swap(_M_fill, __rhs._M_fill);
30741 std::swap(_M_fill_init, __rhs._M_fill_init);
30760 namespace std __attribute__ ((__visibility__ ("default")))
30905 namespace std __attribute__ ((__visibility__ ("default")))
31238 namespace std __attribute__ ((__visibility__ ("default")))
31611 namespace std __attribute__ ((__visibility__ ("default")))
31837 std::swap(_M_gcount, __rhs._M_gcount);
31977 : __istream_type(std::move(__rhs)), __ostream_type(*this)
32019 namespace std __attribute__ ((__visibility__ ("default")))
32662 _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
33069 namespace std __attribute__ ((__visibility__ ("default")))
33242 typedef std::random_access_iterator_tag iterator_category;
34449 namespace std __attribute__ ((__visibility__ ("default")))
34895 namespace std __attribute__ ((__visibility__ ("default")))
35204 namespace std __attribute__ ((__visibility__ ("default")))
36097 return std::fabs(aFloat);
36104 return std::fabs(aDouble);
36111 return std::fabs(aLongDouble);
36864 namespace std __attribute__ ((__visibility__ ("default")))
36902 namespace std __attribute__ ((__visibility__ ("default")))
36925 template<std::size_t __i, typename _Tp>
36929 template<std::size_t __i, typename _Tp>
36932 template<std::size_t __i, typename _Tp>
36938 template<std::size_t __i, typename _Tp>
36944 template<std::size_t __i, typename _Tp>
36953 template<std::size_t __i, typename _Tp>
36965 struct __is_tuple_like_impl<std::pair<_T1, _T2>> : true_type
36970 struct tuple_size<std::pair<_Tp1, _Tp2>>
36971 : public integral_constant<std::size_t, 2> { };
36975 struct tuple_element<0, std::pair<_Tp1, _Tp2>>
36980 struct tuple_element<1, std::pair<_Tp1, _Tp2>>
36983 template<std::size_t _Int>
36991 __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
36996 __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
36997 { return std::forward<_Tp1>(__pair.first); }
37001 __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
37010 __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
37015 __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
37016 { return std::forward<_Tp2>(__pair.second); }
37020 __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
37024 template<std::size_t _Int, class _Tp1, class _Tp2>
37025 constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
37026 get(std::pair<_Tp1, _Tp2>& __in) noexcept
37029 template<std::size_t _Int, class _Tp1, class _Tp2>
37030 constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
37031 get(std::pair<_Tp1, _Tp2>&& __in) noexcept
37032 { return __pair_get<_Int>::__move_get(std::move(__in)); }
37034 template<std::size_t _Int, class _Tp1, class _Tp2>
37035 constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
37036 get(const std::pair<_Tp1, _Tp2>& __in) noexcept
37056 { return std::move(__p.first); }
37071 { return std::move(__p.second); }
37079 { return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
37176 namespace std __attribute__ ((__visibility__ ("default")))
37804 namespace std __attribute__ ((__visibility__ ("default")))
37836 return std::__is_heap_until(__first, __n,
37845 return std::__is_heap_until(__first, __n,
37852 { return std::__is_heap(__first, std::distance(__first, __last)); }
37858 { return std::__is_heap(__first, __comp, std::distance(__first, __last)); }
37873 *(__first + __holeIndex) = std::move(*(__first + __parent));
37877 *(__first + __holeIndex) = std::move(__value);
37897 _ValueType __value = std::move(*(__last - 1));
37898 std::__push_heap(__first, _DistanceType((__last - __first) - 1),
37899 _DistanceType(0), std::move(__value),
37920 _ValueType __value = std::move(*(__last - 1));
37921 std::__push_heap(__first, _DistanceType((__last - __first) - 1),
37922 _DistanceType(0), std::move(__value),
37940 *(__first + __holeIndex) = std::move(*(__first + __secondChild));
37946 *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1)));
37950 std::__push_heap(__first, __holeIndex, __topIndex,
37951 std::move(__value),
37965 _ValueType __value = std::move(*__result);
37966 *__result = std::move(*__first);
37967 std::__adjust_heap(__first, _DistanceType(0),
37969 std::move(__value), __comp);
37989 std::__pop_heap(__first, __last, __last,
38010 std::__pop_heap(__first, __last, __last,
38032 _ValueType __value = std::move(*(__first + __parent));
38033 std::__adjust_heap(__first, __parent, __len, std::move(__value),
38053 std::__make_heap(__first, __last,
38068 std::__make_heap(__first, __last,
38080 std::__pop_heap(__first, __last, __last, __comp);
38097 std::__sort_heap(__first, __last,
38113 std::__sort_heap(__first, __last,
38130 std::__is_heap_until(__first, std::distance(__first, __last),
38146 + std::__is_heap_until(__first, std::distance(__first, __last),
38153 { return std::is_heap_until(__first, __last) == __last; }
38159 { return std::is_heap_until(__first, __last, __comp) == __last; }
38169 namespace std __attribute__ ((__visibility__ ("default")))
38181 { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
38196 std::_Destroy(std::__addressof(*__first));
38219 std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
38236 __traits::destroy(__alloc, std::__addressof(*__first));
38251 namespace std __attribute__ ((__visibility__ ("default")))
38266 std::nothrow));
38268 return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
38271 return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
38277 { ::operator delete(__p, std::nothrow); }
38331 std::_Destroy(_M_buffer, _M_buffer + _M_len);
38332 std::return_temporary_buffer(_M_buffer);
38358 std::_Construct(std::__addressof(*__first),
38359 std::move(*__seed));
38363 std::_Construct(std::__addressof(*__cur),
38364 std::move(*__prev));
38365 *__seed = std::move(*__prev);
38369 std::_Destroy(__first, __cur);
38388 typedef typename std::iterator_traits<_Pointer>::value_type
38391 std::__uninitialized_construct_buf_dispatch<
38399 : _M_original_len(std::distance(__first, __last)),
38404 std::pair<pointer, size_type> __p(std::get_temporary_buffer<
38409 std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len,
38414 std::return_temporary_buffer(_M_buffer);
38432 namespace std __attribute__ ((__visibility__ ("default")))
39887 namespace std __attribute__ ((__visibility__ ("default")))
39906 static_assert(std::is_integral<_IntType>::value,
39919 _IntType __b = std::numeric_limits<_IntType>::max())
39948 _IntType __b = std::numeric_limits<_IntType>::max())
40066 typedef typename std::make_unsigned<result_type>::type __utype;
40067 typedef typename std::common_type<_Gresult_type, __utype>::type
40121 typedef typename std::make_unsigned<result_type>::type __utype;
40122 typedef typename std::common_type<_Gresult_type, __utype>::type
40188 namespace std __attribute__ ((__visibility__ ("default")))
40201 std::iter_swap(__result, __b);
40203 std::iter_swap(__result, __c);
40205 std::iter_swap(__result, __a);
40208 std::iter_swap(__result, __a);
40210 std::iter_swap(__result, __c);
40212 std::iter_swap(__result, __b);
40279 std::__iterator_category(__first));
40288 return std::__find_if(__first, __last,
40290 std::__iterator_category(__first));
40320 return std::__find_if(__first1, __last1,
40330 std::__find_if(__first1, __last1,
40363 std::forward_iterator_tag)
40365 __first = std::__find_if(__first, __last, __unary_pred);
40381 __first = std::__find_if(++__i, __last, __unary_pred);
40395 std::random_access_iterator_tag)
40397 typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
40431 return std::__find_if(__first, __last, __unary_pred);
40433 return std::__search_n_aux(__first, __last, __count, __unary_pred,
40434 std::__iterator_category(__first));
40453 = std::__search(__first1, __last1, __first2, __last2, __comp);
40487 _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
40496 std::advance(__result, -std::distance(__first2, __last2));
40515 return std::__find_end(__first1, __last1, __first2, __last2,
40516 std::__iterator_category(__first1),
40517 std::__iterator_category(__first2),
40537 return std::__find_end(__first1, __last1, __first2, __last2,
40538 std::__iterator_category(__first1),
40539 std::__iterator_category(__first2),
40546 { return __last == std::find_if_not(__first, __last, __pred); }
40551 { return __last == std::find_if(__first, __last, __pred); }
40556 { return !std::none_of(__first, __last, __pred); }
40568 return std::__find_if_not(__first, __last,
40577 __first = std::find_if_not(__first, __last, __pred);
40578 return std::none_of(__first, __last, __pred);
40597 _DistanceType __len = std::distance(__first, __last);
40605 std::advance(__middle, __half);
40647 return std::__remove_copy_if(__first, __last, __result,
40665 return std::__remove_copy_if(__first, __last, __result,
40717 { return std::copy(__first, __first + __n, __result); }
40728 return std::__copy_n(__first, __n, __result,
40729 std::__iterator_category(__first));
40763 __first = std::__find_if(__first, __last, __pred);
40771 *__result = std::move(*__first);
40789 return std::__remove_if(__first, __last,
40805 return std::__remove_if(__first, __last,
40832 __first = std::__adjacent_find(__first, __last, __binary_pred);
40841 *++__dest = std::move(*__first);
40856 return std::__unique(__first, __last,
40873 return std::__unique(__first, __last,
40977 std::iter_swap(__first, __last);
40997 std::iter_swap(__first, __last);
41011 std::__reverse(__first, __last, std::__iterator_category(__first));
41071 std::iter_swap(__first, __first2);
41085 std::iter_swap(__first, __first2);
41113 std::__reverse(__first, __middle, bidirectional_iterator_tag());
41114 std::__reverse(__middle, __last, bidirectional_iterator_tag());
41118 std::iter_swap(__first, --__last);
41124 std::__reverse(__middle, __last, bidirectional_iterator_tag());
41129 std::__reverse(__first, __middle, bidirectional_iterator_tag());
41161 std::swap_ranges(__first, __middle, __middle);
41174 _ValueType __t = std::move(*__p);
41175 std::move(__p + 1, __p + __n, __p);
41176 *(__p + __n - 1) = std::move(__t);
41182 std::iter_swap(__p, __q);
41189 std::swap(__n, __k);
41197 _ValueType __t = std::move(*(__p + __n - 1));
41198 std::move_backward(__p, __p + __n - 1, __p + __n);
41199 *__p = std::move(__t);
41208 std::iter_swap(__p, __q);
41213 std::swap(__n, __k);
41229 return std::__rotate(__first, __middle, __last,
41230 std::__iterator_category(__first));
41247 return std::copy(__first, __middle,
41248 std::copy(__middle, __last, __result));
41269 std::iter_swap(__first, __next);
41299 std::iter_swap(__first, __last);
41324 *__result2 = std::move(*__first);
41330 *__result1 = std::move(*__first);
41335 *__result2 = std::move(*__first);
41339 std::move(__buffer, __result2, __result1);
41344 std::advance(__middle, __len / 2);
41346 std::__stable_partition_adaptive(__first, __middle, __pred,
41354 std::__find_if_not_n(__middle, __right_len, __pred);
41358 std::__stable_partition_adaptive(__right_split, __last, __pred,
41362 std::rotate(__left_split, __middle, __right_split);
41363 std::advance(__left_split, std::distance(__middle, __right_split));
41372 __first = std::__find_if_not(__first, __last, __pred);
41384 std::__stable_partition_adaptive(__first, __last, __pred,
41402 return std::__stable_partition(__first, __last,
41413 std::__make_heap(__first, __middle, __comp);
41416 std::__pop_heap(__first, __middle, __i, __comp);
41444 std::__make_heap(__result_first, __result_real_last, __comp);
41448 std::__adjust_heap(__result_first, _DistanceType(0),
41454 std::__sort_heap(__result_first, __result_real_last, __comp);
41469 return std::__partial_sort_copy(__first, __last,
41487 return std::__partial_sort_copy(__first, __last,
41499 __val = std::move(*__last);
41504 *__last = std::move(*__next);
41508 *__last = std::move(__val);
41524 __val = std::move(*__i);
41525 std::move_backward(__first, __i, __i + 1);
41526 *__first = std::move(__val);
41529 std::__unguarded_linear_insert(__i,
41541 std::__unguarded_linear_insert(__i,
41559 std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
41560 std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
41564 std::__insertion_sort(__first, __last, __comp);
41583 std::iter_swap(__first, __last);
41595 std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
41597 return std::__unguarded_partition(__first + 1, __last, __first, __comp);
41607 std::__heap_select(__first, __middle, __last, __comp);
41608 std::__sort_heap(__first, __middle, __comp);
41622 std::__partial_sort(__first, __last, __last, __comp);
41627 std::__unguarded_partition_pivot(__first, __last, __comp);
41628 std::__introsort_loop(__cut, __last, __depth_limit, __comp);
41642 std::__introsort_loop(__first, __last,
41643 std::__lg(__last - __first) * 2,
41645 std::__final_insertion_sort(__first, __last, __comp);
41659 std::__heap_select(__first, __nth + 1, __last, __comp);
41661 std::iter_swap(__first, __nth);
41666 std::__unguarded_partition_pivot(__first, __last, __comp);
41672 std::__insertion_sort(__first, __last, __comp);
41687 return std::__lower_bound(__first, __last, __val,
41699 _DistanceType __len = std::distance(__first, __last);
41705 std::advance(__middle, __half);
41729 return std::__upper_bound(__first, __last, __val,
41745 return std::__upper_bound(__first, __last, __val,
41759 _DistanceType __len = std::distance(__first, __last);
41765 std::advance(__middle, __half);
41777 = std::__lower_bound(__first, __middle, __val, __comp_it_val);
41778 std::advance(__first, __len);
41780 = std::__upper_bound(++__middle, __first, __val, __comp_val_it);
41801 return std::__equal_range(__first, __last, __val,
41822 return std::__equal_range(__first, __last, __val,
41840 = std::__lower_bound(__first, __last, __val,
41860 = std::__lower_bound(__first, __last, __val,
41879 *__result = std::move(*__first2);
41884 *__result = std::move(*__first1);
41890 std::move(__first1, __last1, __result);
41906 std::move_backward(__first2, __last2, __result);
41918 *--__result = std::move(*__last1);
41921 std::move_backward(__first2, ++__last2, __result);
41928 *--__result = std::move(*__last2);
41952 __buffer_end = std::move(__middle, __last, __buffer);
41953 std::move_backward(__first, __middle, __last);
41954 return std::move(__buffer, __buffer_end, __first);
41963 __buffer_end = std::move(__first, __middle, __buffer);
41964 std::move(__middle, __last, __first);
41965 return std::move_backward(__buffer, __buffer_end, __last);
41972 std::rotate(__first, __middle, __last);
41973 std::advance(__first, std::distance(__middle, __last));
41991 _Pointer __buffer_end = std::move(__first, __middle, __buffer);
41992 std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
41997 _Pointer __buffer_end = std::move(__middle, __last, __buffer);
41998 std::__move_merge_adaptive_backward(__first, __middle, __buffer,
42010 std::advance(__first_cut, __len11);
42012 = std::__lower_bound(__middle, __last, *__first_cut,
42014 __len22 = std::distance(__middle, __second_cut);
42019 std::advance(__second_cut, __len22);
42021 = std::__upper_bound(__first, __middle, *__second_cut,
42023 __len11 = std::distance(__first, __first_cut);
42027 = std::__rotate_adaptive(__first_cut, __middle, __second_cut,
42030 std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
42032 std::__merge_adaptive(__new_middle, __second_cut, __last,
42055 std::iter_swap(__first, __middle);
42066 std::advance(__first_cut, __len11);
42068 = std::__lower_bound(__middle, __last, *__first_cut,
42070 __len22 = std::distance(__middle, __second_cut);
42075 std::advance(__second_cut, __len22);
42077 = std::__upper_bound(__first, __middle, *__second_cut,
42079 __len11 = std::distance(__first, __first_cut);
42082 std::rotate(__first_cut, __middle, __second_cut);
42084 std::advance(__new_middle, std::distance(__middle, __second_cut));
42085 std::__merge_without_buffer(__first, __first_cut, __new_middle,
42087 std::__merge_without_buffer(__new_middle, __second_cut, __last,
42106 const _DistanceType __len1 = std::distance(__first, __middle);
42107 const _DistanceType __len2 = std::distance(__middle, __last);
42113 std::__merge_without_buffer
42116 std::__merge_adaptive
42136 std::__inplace_merge(__first, __middle, __last,
42157 std::__inplace_merge(__first, __middle, __last,
42174 *__result = std::move(*__first2);
42179 *__result = std::move(*__first1);
42184 return std::move(__first2, __last2, std::move(__first1, __last1, __result));
42201 __result = std::__move_merge(__first, __first + __step_size,
42207 __step_size = std::min(_Distance(__last - __first), __step_size);
42209 std::__move_merge(__first, __first + __step_size,
42222 std::__insertion_sort(__first, __first + __chunk_size, __comp);
42225 std::__insertion_sort(__first, __last, __comp);
42243 std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
42247 std::__merge_sort_loop(__first, __last, __buffer,
42250 std::__merge_sort_loop(__buffer, __buffer_last, __first,
42268 std::__stable_sort_adaptive(__first, __middle, __buffer,
42270 std::__stable_sort_adaptive(__middle, __last, __buffer,
42275 std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
42276 std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
42278 std::__merge_adaptive(__first, __middle, __last,
42293 std::__insertion_sort(__first, __last, __comp);
42297 std::__inplace_stable_sort(__first, __middle, __comp);
42298 std::__inplace_stable_sort(__middle, __last, __comp);
42299 std::__merge_without_buffer(__first, __middle, __last,
42337 return std::__includes(__first1, __last1, __first2, __last2,
42354 return std::__includes(__first1, __last1, __first2, __last2,
42381 std::iter_swap(__i, __j);
42382 std::__reverse(__ii, __last,
42383 std::__iterator_category(__first));
42388 std::__reverse(__first, __last,
42389 std::__iterator_category(__first));
42408 return std::__next_permutation
42426 return std::__next_permutation
42453 std::iter_swap(__i, __j);
42454 std::__reverse(__ii, __last,
42455 std::__iterator_category(__first));
42460 std::__reverse(__first, __last,
42461 std::__iterator_category(__first));
42480 return std::__prev_permutation(__first, __last,
42498 return std::__prev_permutation(__first, __last,
42534 return std::__replace_copy_if(__first, __last, __result,
42554 return std::__replace_copy_if(__first, __last, __result,
42573 { return std::is_sorted_until(__first, __last) == __last; }
42579 { return std::is_sorted_until(__first, __last, __comp) == __last; }
42607 return std::__is_sorted_until(__first, __last,
42624 return std::__is_sorted_until(__first, __last,
42658 return std::make_pair(__first, __first);
42706 return std::make_pair(__min, __max);
42721 return std::__minmax_element(__first, __last,
42739 return std::__minmax_element(__first, __last,
42748 { return *std::min_element(__l.begin(), __l.end()); }
42754 { return *std::min_element(__l.begin(), __l.end(), __comp); }
42760 { return *std::max_element(__l.begin(), __l.end()); }
42766 { return *std::max_element(__l.begin(), __l.end(), __comp); }
42774 std::minmax_element(__l.begin(), __l.end());
42775 return std::make_pair(*__p.first, *__p.second);
42784 std::minmax_element(__l.begin(), __l.end(), __comp);
42785 return std::make_pair(*__p.first, *__p.second);
42806 std::advance(__last2, std::distance(__first1, __last1));
42809 if (__scan != std::__find_if(__first1, __scan,
42814 = std::__count_if(__first2, __last2,
42817 std::__count_if(__scan, __last1,
42838 return std::__is_permutation(__first1, __last1, __first2,
42856 return std::__is_permutation(__first1, __last1, __first2,
42877 auto __d1 = std::distance(__first1, __last1);
42878 auto __d2 = std::distance(__first2, __last2);
42897 auto __d1 = std::distance(__first1, __last1);
42898 auto __d2 = std::distance(__first2, __last2);
42907 if (__scan != std::__find_if(__first1, __scan,
42911 auto __matches = std::__count_if(__first2, __last2,
42914 || std::__count_if(__scan, __last1,
42931 std::__is_permutation(__first1, __last1, __first2, __last2,
42945 return std::__is_permutation(__first1, __last1, __first2, __last2,
42966 typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
42967 typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
42972 std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
42984 return std::move(__f);
42997 return std::__find_if(__first, __last,
43012 return std::__find_if(__first, __last,
43070 return std::__adjacent_find(__first, __last,
43086 return std::__adjacent_find(__first, __last,
43100 return std::__count_if(__first, __last,
43114 return std::__count_if(__first, __last,
43132 return std::__search(__first1, __last1, __first2, __last2,
43152 return std::__search(__first1, __last1, __first2, __last2,
43167 return std::__search_n(__first, __last, __count,
43184 return std::__search_n(__first, __last, __count,
43309 return std::__unique_copy(__first, __last, __result,
43311 std::__iterator_category(__first),
43312 std::__iterator_category(__result));
43330 return std::__unique_copy(__first, __last, __result,
43332 std::__iterator_category(__first),
43333 std::__iterator_category(__result));
43350 + std::rand() % ((__i - __first) + 1);
43352 std::iter_swap(__i, __j);
43376 std::iter_swap(__i, __j);
43392 return std::__partition(__first, __last, __pred,
43393 std::__iterator_category(__first));
43411 std::__partial_sort(__first, __middle, __last,
43432 std::__partial_sort(__first, __middle, __last,
43453 std::__introselect(__first, __nth, __last,
43454 std::__lg(__last - __first) * 2,
43476 std::__introselect(__first, __nth, __last,
43477 std::__lg(__last - __first) * 2,
43493 std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
43510 std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
43534 return std::copy(__first2, __last2,
43535 std::copy(__first1, __last1, __result));
43551 return std::__merge(__first1, __last1,
43569 return std::__merge(__first1, __last1,
43588 std::__inplace_stable_sort(__first, __last, __comp);
43590 std::__stable_sort_adaptive(__first, __last, __buf.begin(),
43606 std::__stable_sort(__first, __last,
43624 std::__stable_sort(__first, __last,
43656 return std::copy(__first2, __last2,
43657 std::copy(__first1, __last1, __result));
43673 return std::__set_union(__first1, __last1,
43691 return std::__set_union(__first1, __last1,
43732 return std::__set_intersection(__first1, __last1,
43750 return std::__set_intersection(__first1, __last1,
43777 return std::copy(__first1, __last1, __result);
43793 return std::__set_difference(__first1, __last1,
43811 return std::__set_difference(__first1, __last1,
43845 return std::copy(__first2, __last2,
43846 std::copy(__first1, __last1, __result));
43862 return std::__set_symmetric_difference(__first1, __last1,
43881 return std::__set_symmetric_difference(__first1, __last1,
43913 return std::__min_element(__first, __last,
43931 return std::__min_element(__first, __last,
43961 return std::__max_element(__first, __last,
43979 return std::__max_element(__first, __last,
43990 namespace std __attribute__ ((__visibility__ ("default")))
43994 template<typename _Tp, std::size_t _Nm>
44000 _S_ref(const _Type& __t, std::size_t __n) noexcept
44014 _S_ref(const _Type&, std::size_t) noexcept
44022 template<typename _Tp, std::size_t _Nm>
44032 typedef std::size_t size_type;
44033 typedef std::ptrdiff_t difference_type;
44034 typedef std::reverse_iterator<iterator> reverse_iterator;
44035 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
44038 typedef std::__array_traits<_Tp, _Nm> _AT_Type;
44046 { std::fill_n(begin(), size(), __u); }
44051 { std::swap_ranges(begin(), end(), __other.begin()); }
44125 std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"),
44137 : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"),
44172 template<typename _Tp, std::size_t _Nm>
44175 { return std::equal(__one.begin(), __one.end(), __two.begin()); }
44177 template<typename _Tp, std::size_t _Nm>
44182 template<typename _Tp, std::size_t _Nm>
44186 return std::lexicographical_compare(__a.begin(), __a.end(),
44190 template<typename _Tp, std::size_t _Nm>
44195 template<typename _Tp, std::size_t _Nm>
44200 template<typename _Tp, std::size_t _Nm>
44206 template<typename _Tp, std::size_t _Nm>
44212 template<std::size_t _Int, typename _Tp, std::size_t _Nm>
44217 return std::__array_traits<_Tp, _Nm>::
44221 template<std::size_t _Int, typename _Tp, std::size_t _Nm>
44226 return std::move(std::get<_Int>(__arr));
44229 template<std::size_t _Int, typename _Tp, std::size_t _Nm>
44234 return std::__array_traits<_Tp, _Nm>::
44241 namespace std __attribute__ ((__visibility__ ("default")))
44252 template<typename _Tp, std::size_t _Nm>
44253 struct tuple_size<std::array<_Tp, _Nm>>
44254 : public integral_constant<std::size_t, _Nm> { };
44257 template<std::size_t _Int, typename _Tp>
44261 template<std::size_t _Int, typename _Tp, std::size_t _Nm>
44262 struct tuple_element<_Int, std::array<_Tp, _Nm>>
44268 template<typename _Tp, std::size_t _Nm>
44269 struct __is_tuple_like_impl<std::array<_Tp, _Nm>> : true_type
44340 struct is_std_array_oracle<std::array<ElementType, Extent>> : mozilla::TrueType
44370 using iterator_category = std::random_access_iterator_tag;
44516 std::swap(index_, rhs.index_);
44517 std::swap(span_, rhs.span_);
44598 using reverse_iterator = std::reverse_iterator<iterator>;
44599 using const_reverse_iterator = std::reverse_iterator<const_iterator>;
44621 constexpr Span(std::nullptr_t) : Span() {}
44635 : storage_(aStartPtr, std::distance(aStartPtr, aEndPtr))
44653 constexpr Span(std::array<ArrayElementType, N>& aArr)
44663 const std::array<span_details::remove_const_t<element_type>, N>& aArr)
44691 template<class ArrayElementType = std::add_pointer<element_type>>
44999 return (l.size() == r.size()) && std::equal(l.begin(), l.end(), r.begin());
45015 return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
45176 return Span<const char>(aZeroTerminated, std::strlen(aZeroTerminated));
48068 namespace std __attribute__ ((__visibility__ ("default")))
48776 namespace std __attribute__ ((__visibility__ ("default")))
48912 "std::atomic requires a trivially copyable type");
49996 static const std::memory_order AtomicRMWOrder = std::memory_order_relaxed;
49997 static const std::memory_order LoadOrder = std::memory_order_relaxed;
49998 static const std::memory_order StoreOrder = std::memory_order_relaxed;
49999 static const std::memory_order CompareExchangeFailureOrder =
50000 std::memory_order_relaxed;
50006 static const std::memory_order AtomicRMWOrder = std::memory_order_acq_rel;
50007 static const std::memory_order LoadOrder = std::memory_order_acquire;
50008 static const std::memory_order StoreOrder = std::memory_order_release;
50009 static const std::memory_order CompareExchangeFailureOrder =
50010 std::memory_order_acquire;
50016 static const std::memory_order AtomicRMWOrder = std::memory_order_seq_cst;
50017 static const std::memory_order LoadOrder = std::memory_order_seq_cst;
50018 static const std::memory_order StoreOrder = std::memory_order_seq_cst;
50019 static const std::memory_order CompareExchangeFailureOrder =
50020 std::memory_order_seq_cst;
50026 typedef std::atomic<T> ValueType;
51790 return mValue.fetch_add(1, std::memory_order_relaxed) + 1;
51798 nsrefcnt result = mValue.fetch_sub(1, std::memory_order_release) - 1;
51804 result = mValue.load(std::memory_order_acquire);
51813 mValue.store(aValue, std::memory_order_release);
51821 return mValue.load(std::memory_order_acquire);
51828 std::atomic<nsrefcnt> mValue;
52629 namespace std
52761 namespace std __attribute__ ((__visibility__ ("default")))
52834 __ret._M_a = std::__addressof(__a);
52842 namespace std __attribute__ ((__visibility__ ("default")))
52851 template<std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal>
52854 template<std::size_t _Idx, typename _Head>
52869 : _Head(std::forward<_UHead>(__h)) { }
52884 : _Head(std::forward<_UHead>(__uhead)) { }
52888 : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
52892 : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
52901 template<std::size_t _Idx, typename _Head>
52915 : _M_head_impl(std::forward<_UHead>(__h)) { }
52930 : _M_head_impl(std::forward<_UHead>(__uhead)) { }
52934 : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
52939 : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
52950 template<std::size_t _Idx, typename... _Elements>
52971 template<std::size_t _Idx, typename _Head, typename... _Tail>
52976 template<std::size_t, typename...> friend class _Tuple_impl;
53004 : _Inherited(std::forward<_UTail>(__tail)...),
53005 _Base(std::forward<_UHead>(__head)) { }
53013 : _Inherited(std::move(_M_tail(__in))),
53014 _Base(std::forward<_Head>(_M_head(__in))) { }
53023 : _Inherited(std::move
53025 _Base(std::forward<_UHead>
53044 : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
53046 std::forward<_UHead>(__head)) { }
53057 : _Inherited(__tag, __a, std::move(_M_tail(__in))),
53059 std::forward<_Head>(_M_head(__in))) { }
53072 : _Inherited(__tag, __a, std::move
53075 std::forward<_UHead>
53091 _M_head(*this) = std::forward<_Head>(_M_head(__in));
53092 _M_tail(*this) = std::move(_M_tail(__in));
53109 _M_head(*this) = std::forward<_UHead>
53111 _M_tail(*this) = std::move
53122 using std::swap;
53129 template<std::size_t _Idx, typename _Head>
53133 template<std::size_t, typename...> friend class _Tuple_impl;
53153 : _Base(std::forward<_UHead>(__head)) { }
53160 : _Base(std::forward<_Head>(_M_head(__in))) { }
53168 : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
53184 std::forward<_UHead>(__head)) { }
53195 std::forward<_Head>(_M_head(__in))) { }
53207 std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
53221 _M_head(*this) = std::forward<_Head>(_M_head(__in));
53238 = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
53247 using std::swap;
53429 : _Inherited(std::forward<_UElements>(__elements)...) { }
53442 : _Inherited(std::forward<_UElements>(__elements)...) { }
53536 : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
53547 : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
53617 static_cast<_Inherited&>(*this) = std::move(__in);
53637 static_cast<_Inherited&>(*this) = std::move(__in);
53721 : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
53730 : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
53797 : _Inherited(std::forward<_U1>(__in.first),
53798 std::forward<_U2>(__in.second)) { }
53807 : _Inherited(std::forward<_U1>(__in.first),
53808 std::forward<_U2>(__in.second)) { }
53847 : _Inherited(__tag, __a, std::forward<_U1>(__a1),
53848 std::forward<_U2>(__a2)) { }
53858 : _Inherited(__tag, __a, std::forward<_U1>(__a1),
53859 std::forward<_U2>(__a2)) { }
53941 : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
53942 std::forward<_U2>(__in.second)) { }
53952 : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
53953 std::forward<_U2>(__in.second)) { }
53966 static_cast<_Inherited&>(*this) = std::move(__in);
53982 static_cast<_Inherited&>(*this) = std::move(__in);
53999 this->_M_head(*this) = std::forward<_U1>(__in.first);
54000 this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
54015 template<std::size_t __i, typename _Head, typename... _Tail>
54031 : public integral_constant<std::size_t, sizeof...(_Elements)> { };
54033 template<std::size_t __i, typename _Head, typename... _Tail>
54038 template<std::size_t __i, typename _Head, typename... _Tail>
54044 template<std::size_t __i, typename... _Elements>
54047 { return std::__get_helper<__i>(__t); }
54050 template<std::size_t __i, typename... _Elements>
54053 { return std::__get_helper<__i>(__t); }
54056 template<std::size_t __i, typename... _Elements>
54061 return std::forward<__element_type&&>(std::get<__i>(__t));
54082 { return std::__get_helper2<_Tp>(__t); }
54088 { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }
54094 { return std::__get_helper2<_Tp>(__t); }
54104 return bool(std::get<__i>(__t) == std::get<__i>(__u))
54111 return bool(std::get<__i>(__t) < std::get<__i>(__u))
54112 || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
54184 return __result_type(std::forward<_Elements>(__args)...);
54192 { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
54201 : public __is_tuple_like_impl<typename std::remove_cv
54202 <typename std::remove_reference<_Tp>::type>::type>::type
54215 template<std::size_t _Nm, typename _Tuple, typename... _Tp>
54223 : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
54229 : public __do_make_tuple<typename std::remove_cv
54230 <typename std::remove_reference<_Tuple>::type>::type>
54272 typedef std::_Index_tuple<> __type;
54278 typedef typename std::_Build_index_tuple<std::tuple_size<
54279 typename std::remove_reference<_Tp>::type>::value>::__type __type;
54288 template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
54289 struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
54297 return __next::_S_do(std::forward<_Tpls>(__tps)...,
54298 std::forward<_Us>(__us)...,
54299 std::get<_Is>(std::forward<_Tp>(__tp))...);
54304 struct __tuple_concater<_Ret, std::_Index_tuple<>>
54310 return _Ret(std::forward<_Us>(__us)...);
54324 return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
54371 template<typename... _Args1, std::size_t... _Indexes1,
54372 typename... _Args2, std::size_t... _Indexes2>
54377 : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
54378 second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
54390 namespace std __attribute__ ((__visibility__ ("default")))
54539 noexcept(noexcept(std::forward<_Fn>(__f)(std::forward<_Args>(__args)...)))
54540 { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }
54547 (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...)))
54548 { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); }
54555 ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...)))
54557 return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...);
54569 noexcept(noexcept((*std::forward<_Tp>(__t)).*__f))
54570 { return (*std::forward<_Tp>(__t)).*__f; }
54580 return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
54581 std::forward<_Args>(__args)...);
54756 : _M_data(std::__addressof(__indata))
54777 return std::__invoke(get(), std::forward<_Args>(__args)...);
54828 using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type,
54829 typename std::decay<_Tp2>::type>>;
54842 : std::unary_function<_T1, _Res> { };
54847 : std::binary_function<_T1, _T2, _Res> { };
54894 std::__invoke(_M_pmf, std::forward<_Args>(__args)...)))
54895 -> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...))
54896 { return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); }
54918 noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj))))
54919 -> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))
54920 { return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); }
55008 template<std::size_t __i, typename _Tuple>
55062 template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
55068 return __arg(std::forward<_Args>(std::get<_Indexes>(__tuple))...);
55087 return std::forward<__type>(
55088 ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
55104 { return std::forward<_CVArg>(__arg); }
55152 template<std::size_t _Ind, typename... _Tp>
55156 { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }
55159 template<std::size_t _Ind, typename... _Tp>
55163 { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
55181 template<typename _Result, typename... _Args, std::size_t... _Indexes>
55186 (std::get<_Indexes>(_M_bound_args), __args)...);
55190 template<typename _Result, typename... _Args, std::size_t... _Indexes>
55195 (std::get<_Indexes>(_M_bound_args), __args)...);
55199 template<typename _Result, typename... _Args, std::size_t... _Indexes>
55209 template<typename _Result, typename... _Args, std::size_t... _Indexes>
55221 : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
55226 : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
55232 : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
55237 = decltype( std::declval<_Functor&>()(
55238 _Mu<_Bound_args>()( std::declval<_Bound_args&>(),
55239 std::declval<tuple<_Args...>&>() )... ) )>
55244 std::forward_as_tuple(std::forward<_Args>(__args)...),
55250 = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
55252 _Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
55253 std::declval<tuple<_Args...>&>() )... ) )>
55258 std::forward_as_tuple(std::forward<_Args>(__args)...),
55264 = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
55266 _Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
55267 std::declval<tuple<_Args...>&>() )... ) )>
55272 std::forward_as_tuple(std::forward<_Args>(__args)...),
55278 = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
55280 _Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
55281 std::declval<tuple<_Args...>&>() )... ) )>
55286 std::forward_as_tuple(std::forward<_Args>(__args)...),
55312 template<typename _Res, typename... _Args, std::size_t... _Indexes>
55318 (std::get<_Indexes>(_M_bound_args), __args)...);
55322 template<typename _Res, typename... _Args, std::size_t... _Indexes>
55328 (std::get<_Indexes>(_M_bound_args), __args)...);
55332 template<typename _Res, typename... _Args, std::size_t... _Indexes>
55338 (std::get<_Indexes>(_M_bound_args), __args)...);
55342 template<typename _Res, typename... _Args, std::size_t... _Indexes>
55348 (std::get<_Indexes>(_M_bound_args), __args)...);
55352 template<typename _Res, typename... _Args, std::size_t... _Indexes>
55362 template<typename _Res, typename... _Args, std::size_t... _Indexes>
55372 template<typename _Res, typename... _Args, std::size_t... _Indexes>
55382 template<typename _Res, typename... _Args, std::size_t... _Indexes>
55397 : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
55402 : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
55408 : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
55417 std::forward_as_tuple(std::forward<_Args>(__args)...),
55427 std::forward_as_tuple(std::forward<_Args>(__args)...),
55437 std::forward_as_tuple(std::forward<_Args>(__args)...),
55447 std::forward_as_tuple(std::forward<_Args>(__args)...),
55579 return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
55580 std::forward<_BoundArgs>(__args)...);
55607 return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
55608 std::forward<_BoundArgs>(__args)...);
55622 : _M_bound(std::forward<_Tp>(__f), std::forward<_Up>(__args)...)
55636 template<std::size_t... _Indices>
55642 return std::forward<_Callable>(std::get<0>(_M_bound))(
55643 std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
55646 std::tuple<_Callable, _Args...> _M_bound;
55670 __maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
55671 std::forward<_Args>(__args)...);
55679 class bad_function_call : public std::exception
55760 { return std::mem_fn(__p); }
55765 { return std::mem_fn(__p); }
55770 { return std::mem_fn(__p); }
55775 { return std::mem_fn(__p); }
55784 static const std::size_t _M_max_size = sizeof(_Nocopy_types);
55785 static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
55804 __stored_locally? std::__addressof(__source._M_access<_Functor>())
55870 { _M_init_functor(__functor, std::move(__f), _Local_storage()); }
55895 { ::new (__functor._M_access()) _Functor(std::move(__f)); }
55899 { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
55933 _Base::_M_init_functor(__functor, std::__addressof(__f.get()));
55969 std::forward<_ArgTypes>(__args)...);
55984 std::forward<_ArgTypes>(__args)...);
55998 return std::__callable_functor(**_Base::_M_get_pointer(__functor))(
55999 std::forward<_ArgTypes>(__args)...);
56013 std::__callable_functor(**_Base::_M_get_pointer(__functor))(
56014 std::forward<_ArgTypes>(__args)...);
56030 return std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
56031 std::forward<_ArgTypes>(__args)...);
56070 std::mem_fn(_Base::_M_get_pointer(__functor)->__value)(
56071 std::forward<_ArgTypes>(__args)...);
56145 function(std::move(__x)).swap(*this);
56165 function(std::forward<_Functor>(__f)).swap(*this);
56180 std::swap(_M_functor, __x._M_functor);
56181 std::swap(_M_manager, __x._M_manager);
56182 std::swap(_M_invoker, __x._M_invoker);
56227 _My_handler::_M_init_functor(_M_functor, std::move(__f));
56240 return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
56904 struct nsTArray_CopyChooser<std::function<T>>
56906 typedef nsTArray_CopyWithConstructors<std::function<T>> Type;
57039 explicit nsTArray_Impl(std::initializer_list<E> aIL) { AppendElements(aIL.begin(), aIL.size()); }
58249 nsTArray(std::initializer_list<E> aIL) : base_type(aIL) {}
58394 AutoTArray(std::initializer_list<E> aIL)
59783 return FromTicks(std::max(aA.mValue, aB.mValue));
59788 return FromTicks(std::min(aA.mValue, aB.mValue));
59883 friend std::ostream& operator<<(std::ostream& aStream,
65699 operator==(std::nullptr_t a, const T& b) {
65706 operator!=(std::nullptr_t a, const T& b) {
65713 operator==(const T& a, std::nullptr_t b) {
65720 operator!=(const T& a, std::nullptr_t b) {
72027 std::atomic<uint32_t> mRefCount;
72078 return mRefCount.load(std::memory_order_relaxed) > 1;
72781 using std::abs;
72782 using std::acos;
72783 using std::asin;
72784 using std::atan;
72785 using std::atan2;
72786 using std::cos;
72787 using std::sin;
72788 using std::tan;
72789 using std::cosh;
72790 using std::sinh;
72791 using std::tanh;
72792 using std::exp;
72793 using std::frexp;
72794 using std::ldexp;
72795 using std::log;
72796 using std::log10;
72797 using std::modf;
72798 using std::pow;
72799 using std::sqrt;
72800 using std::ceil;
72801 using std::fabs;
72802 using std::floor;
72803 using std::fmod;
72806 using std::fpclassify;
72807 using std::isfinite;
72808 using std::isinf;
72809 using std::isnan;
72810 using std::isnormal;
72811 using std::signbit;
72812 using std::isgreater;
72813 using std::isgreaterequal;
72814 using std::isless;
72815 using std::islessequal;
72816 using std::islessgreater;
72817 using std::isunordered;
72821 using std::acosh;
72822 using std::asinh;
72823 using std::atanh;
72824 using std::cbrt;
72825 using std::copysign;
72826 using std::erf;
72827 using std::erfc;
72828 using std::exp2;
72829 using std::expm1;
72830 using std::fdim;
72831 using std::fma;
72832 using std::fmax;
72833 using std::fmin;
72834 using std::hypot;
72835 using std::ilogb;
72836 using std::lgamma;
72837 using std::llrint;
72838 using std::llround;
72839 using std::log1p;
72840 using std::log2;
72841 using std::logb;
72842 using std::lrint;
72843 using std::lround;
72844 using std::nearbyint;
72845 using std::nextafter;
72846 using std::nexttoward;
72847 using std::remainder;
72848 using std::remquo;
72849 using std::rint;
72850 using std::round;
72851 using std::scalbln;
72852 using std::scalbn;
72853 using std::tgamma;
72854 using std::trunc;
72963 return NSToCoordRoundWithClamp(std::min<float>(nscoord(1 << 30), product));
72964 return NSToCoordRoundWithClamp(std::max<float>((-nscoord(1 << 30)), product));
73002 return std::min(nscoord(1 << 30), a + b);
73034 return std::min(nscoord(1 << 30), a - b);
73401 return Sub(std::min(aA.width, aB.width),
73402 std::min(aA.height, aB.height));
73406 return Sub(std::max(aA.width, aB.width),
73407 std::max(aA.height, aB.height));
73410 friend std::ostream& operator<<(std::ostream& aStream,
73529 x = std::max(std::min(x, aMaxAbsValue), -aMaxAbsValue);
73530 y = std::max(std::min(y, aMaxAbsValue), -aMaxAbsValue);
73533 friend std::ostream& operator<<(std::ostream& stream, const BasePoint<T, Sub, Coord>& aPoint) {
75087 friend std::ostream& operator<<(std::ostream& aStream,
75189 result.x = std::max<T>(x, aRect.x);
75190 result.y = std::max<T>(y, aRect.y);
75191 result.width = std::min<T>(x - result.x + width, aRect.x - result.x + aRect.width);
75192 result.height = std::min<T>(y - result.y + height, aRect.y - result.y + aRect.height);
75234 result.x = std::min(x, aRect.x);
75235 result.y = std::min(y, aRect.y);
75236 result.width = std::max(XMost(), aRect.XMost()) - result.x;
75237 result.height = std::max(YMost(), aRect.YMost()) - result.y;
75315 width = std::max(T(0), width - 2 * aDx);
75316 height = std::max(T(0), height - 2 * aDy);
75322 width = std::max(T(0), width - aMargin.LeftRight());
75323 height = std::max(T(0), height - aMargin.TopBottom());
75558 width = std::max<T>(0, right - x);
75559 height = std::max<T>(0, bottom - y);
75590 width = std::max<T>(0, right - x);
75591 height = std::max<T>(0, bottom - y);
75600 return Point(std::max(x, std::min(XMost(), aPoint.x)),
75601 std::max(y, std::min(YMost(), aPoint.y)));
75611 Sub rect(std::max(aRect.x, x),
75612 std::max(aRect.y, y),
75613 std::min(aRect.width, width),
75614 std::min(aRect.height, height));
75615 rect.x = std::min(rect.XMost(), aRect.XMost()) - rect.width;
75616 rect.y = std::min(rect.YMost(), aRect.YMost()) - rect.height;
75629 static_cast<T>(-std::numeric_limits<int32_t>::max() * 0.5),
75630 static_cast<T>(-std::numeric_limits<int32_t>::max() * 0.5),
75631 static_cast<T>(std::numeric_limits<int32_t>::max()),
75632 static_cast<T>(std::numeric_limits<int32_t>::max())
75636 friend std::ostream& operator<<(std::ostream& stream,
76573 typename std::enable_if<std::is_convertible<U, T>::value>::type>
76597 typename std::enable_if<std::is_convertible<U, T>::value>::type>
76626 typename std::enable_if<std::is_convertible<U, T>::value>::type>
76661 typename std::enable_if<std::is_convertible<U, T>::value>::type>
76919 friend std::ostream&
76920 operator<<(std::ostream& aStream, const Maybe<T>& aMaybe)
76932 typename U = typename std::remove_cv<
76933 typename std::remove_reference<T>::type>::type>
77212 CheckedInt<int32_t> newX = std::min(this->x, aRect.x);
77213 CheckedInt<int32_t> newY = std::min(this->y, aRect.y);
77214 CheckedInt<int32_t> newXMost = std::max(this->XMost(), aRect.XMost());
77215 CheckedInt<int32_t> newYMost = std::max(this->YMost(), aRect.YMost());
78367 return detail::MakeNumberValue<std::numeric_limits<T>::is_signed>::create(t);
80038 : public std::integral_constant<bool, (EnumSize <= StorageSize)>
80044 : public std::integral_constant<bool, false>
80050 : public std::integral_constant<bool, (EnumSize * 2 <= StorageSize)>
80056 : public std::integral_constant<bool, (EnumSize <= StorageSize)>
80065 std::is_signed<typename std::underlying_type<T>::type>::value,
80067 std::is_signed<Storage>::value
80070 static_assert(std::is_enum<T>::value, "must provide an enum type");
80071 static_assert(std::is_integral<Storage>::value, "must provide an integral type");
80272 typename = typename std::enable_if<std::is_enum<T>::value>::type>
84579 void RemoveElementsBy(std::function<bool(const elem_type&)> aPredicate)
86796 friend std::ostream& operator<<(std::ostream& aStream,
87912 friend std::ostream& operator<<(std::ostream& aStream, const nsINode& aNode);
97419 size_t toAdvance = std::min(bytes, RemainingInSegment());
97551 size_t toCopy = std::min(aSize, lastSegment.mCapacity - lastSegment.mSize);
97561 size_t toCopy = std::min(remaining, mStandardCapacity);
97583 size_t toCopy = std::min(aIter.RemainingInSegment(), remaining);
97607 size_t toAdvance = std::min(size, aIter.RemainingInSegment());
97658 size_t toCopy = std::min(size, aIter.RemainingInSegment());
102478 class iterator : public std::iterator<std::input_iterator_tag, js::UniquePtr<Note>>
106548 F minX = std::min(std::min(p1.x, p2.x), p3.x);
106549 F maxX = std::max(std::max(p1.x, p2.x), p3.x);
106551 F minY = std::min(std::min(p1.y, p2.y), p3.y);
106552 F maxY = std::max(std::max(p1.y, p2.y), p3.y);
106625 friend std::ostream& operator<<(std::ostream& aStream, const Quaternion& aQuat);
106739 friend std::ostream& operator<<(std::ostream& aStream, const Matrix& aMatrix);
107131 friend std::ostream& operator<<(std::ostream& aStream, const Matrix4x4Typed& aMatrix)
107134 aStream << "[ " << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ;" << std::endl; f += 4;
107135 aStream << " " << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ;" << std::endl; f += 4;
107136 aStream << " " << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ;" << std::endl; f += 4;
107137 aStream << " " << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ]" << std::endl;
107261 F min_x = std::numeric_limits<F>::max();
107262 F min_y = std::numeric_limits<F>::max();
107263 F max_x = -std::numeric_limits<F>::max();
107264 F max_y = -std::numeric_limits<F>::max();
107270 min_x = std::min<F>(point2d.x, min_x);
107271 max_x = std::max<F>(point2d.x, max_x);
107272 min_y = std::min<F>(point2d.y, min_y);
107273 max_y = std::max<F>(point2d.y, max_y);
107316 F min_x = std::numeric_limits<F>::max();
107317 F min_y = std::numeric_limits<F>::max();
107318 F max_x = -std::numeric_limits<F>::max();
107319 F max_y = -std::numeric_limits<F>::max();
107321 min_x = std::min(min_x, verts[i].x);
107322 max_x = std::max(max_x, verts[i].x);
107323 min_y = std::min(min_y, verts[i].y);
107324 max_y = std::max(max_y, verts[i].y);
107664 std::swap(_12, _21);
107665 std::swap(_13, _31);
107666 std::swap(_14, _41);
107668 std::swap(_23, _32);
107669 std::swap(_24, _42);
107671 std::swap(_34, _43);
108673 result.x = std::min(aRect.x, x);
108674 int64_t w = std::max(int64_t(aRect.x) + aRect.width, int64_t(x) + width) - result.x;
108677 result.x = std::max(result.x, (-nscoord(1 << 30)) / 2);
108678 w = std::max(int64_t(aRect.x) + aRect.width, int64_t(x) + width) - result.x;
108685 result.y = std::min(aRect.y, y);
108686 int64_t h = std::max(int64_t(aRect.y) + aRect.height, int64_t(y) + height) - result.y;
108689 result.y = std::max(result.y, (-nscoord(1 << 30)) / 2);
108690 h = std::max(int64_t(aRect.y) + aRect.height, int64_t(y) + height) - result.y;
108818 rect.width = std::max(0, NSToIntRoundUp(NSAppUnitsToDoublePixels(XMost(),
108820 rect.height = std::max(0, NSToIntRoundUp(NSAppUnitsToDoublePixels(YMost(),
108834 rect.width = std::max(0, NSToIntCeil(NSAppUnitsToFloatPixels(XMost(),
108836 rect.height = std::max(0, NSToIntCeil(NSAppUnitsToFloatPixels(YMost(),
108850 rect.width = std::max(0, NSToIntFloor(NSAppUnitsToFloatPixels(XMost(),
108852 rect.height = std::max(0, NSToIntFloor(NSAppUnitsToFloatPixels(YMost(),
109100 NS_ABORT_OOM(std::max(aSize, ArenaSize));
109235 ArenaChunk* arena = AllocateChunk(std::max(kMaxArenaCapacity, aSize));
110262 friend std::ostream& operator<<(std::ostream& aStream,
111336 friend std::ostream& operator<<(std::ostream& stream, const nsRegion& m);
111719 friend std::ostream& operator<<(std::ostream& stream, const Derived& m) {
112670 return gfx::ScaleFactor<src, dst>(std::max(aDestSize.width / aSrcSize.width,
112676 return gfx::ScaleFactor<src, dst>(std::min(aDestSize.width / aSrcSize.width,
116201 template<std::size_t Index, typename... Elements>
116208 template<std::size_t Index>
116221 template<std::size_t Index, typename HeadT, typename... TailT>
116395 explicit Tuple(const std::pair<A, B>& aOther)
116397 explicit Tuple(std::pair<A, B>&& aOther) : Impl(Forward<A>(aOther.first),
116437 Tuple& operator=(const std::pair<AArg, BArg>& aOther)
116444 Tuple& operator=(std::pair<AArg, BArg>&& aOther)
116463 template<std::size_t Index, typename... Elements>
116471 template<std::size_t Index, typename... Elements>
116480 template<std::size_t Index, typename... Elements>
116488 template<std::size_t Index, typename... Elements>
116496 template<std::size_t Index, typename... Elements>
118006 typename = typename std::enable_if<std::is_enum<T>::value>::type>
118029 typename = typename std::enable_if<std::is_enum<T>::value>::type>
128930 namespace std __attribute__ ((__visibility__ ("default")))
128946 std::_Construct(std::__addressof(*__cur), *__first);
128951 std::_Destroy(__result, __cur);
128964 { return std::copy(__first, __last, __result); }
128985 return std::__uninitialized_copy<__is_trivial(_ValueType1)
129004 std::_Construct(std::__addressof(*__cur), __x);
129008 std::_Destroy(__first, __cur);
129021 { std::fill(__first, __last, __x); }
129038 std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>::
129055 std::_Construct(std::__addressof(*__cur), __x);
129060 std::_Destroy(__first, __cur);
129073 { return std::fill_n(__first, __n, __x); }
129109 __traits::construct(__alloc, std::__addressof(*__cur), *__first);
129114 std::_Destroy(__result, __cur, __alloc);
129123 { return std::uninitialized_copy(__first, __last, __result); }
129131 return std::__uninitialized_copy_a(std::make_move_iterator(__first),
129132 std::make_move_iterator(__last),
129144 return std::__uninitialized_copy_a
129145 (std::__make_move_if_noexcept_iterator(__first),
129146 std::__make_move_if_noexcept_iterator(__last), __result, __alloc);
129159 __traits::construct(__alloc, std::__addressof(*__cur), __x);
129163 std::_Destroy(__first, __cur, __alloc);
129172 { std::uninitialized_fill(__first, __last, __x); }
129185 __traits::construct(__alloc, std::__addressof(*__cur), __x);
129190 std::_Destroy(__first, __cur, __alloc);
129200 { return std::uninitialized_fill_n(__first, __n, __x); }
129212 _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
129217 return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
129221 std::_Destroy(__result, __mid, __alloc);
129240 _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
129245 return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
129249 std::_Destroy(__result, __mid, __alloc);
129264 std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
129267 return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
129271 std::_Destroy(__result, __mid, __alloc);
129287 _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
129292 std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
129296 std::_Destroy(__first2, __mid2, __alloc);
129316 std::_Construct(std::__addressof(*__cur));
129320 std::_Destroy(__first, __cur);
129336 std::fill(__first, __last, _ValueType());
129351 std::_Construct(std::__addressof(*__cur));
129356 std::_Destroy(__first, __cur);
129372 return std::fill_n(__first, __n, _ValueType());
129389 std::__uninitialized_default_1<__is_trivial(_ValueType)
129425 __traits::construct(__alloc, std::__addressof(*__cur));
129429 std::_Destroy(__first, __cur, __alloc);
129439 { std::__uninitialized_default(__first, __last); }
129455 __traits::construct(__alloc, std::__addressof(*__cur));
129460 std::_Destroy(__first, __cur, __alloc);
129469 { return std::__uninitialized_default_n(__first, __n); }
129482 std::_Construct(std::__addressof(*__cur), *__first);
129487 std::_Destroy(__result, __cur);
129498 { return std::uninitialized_copy(__first, __first + __n, __result); }
129504 { return std::__uninitialized_copy_n(__first, __n, __result,
129505 std::__iterator_category(__first)); }
129513 namespace std __attribute__ ((__visibility__ ("default")))
129545 typedef std::random_access_iterator_tag iterator_category;
129808 { return std::copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
129823 { return std::copy_backward(_Deque_iterator<_Tp,
129841 { return std::move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
129856 { return std::move_backward(_Deque_iterator<_Tp,
129915 : _M_impl(std::move(__x._M_get_Tp_allocator()))
129923 : _Deque_base(std::move(__x), typename _Alloc_traits::is_always_equal{})
129974 : _Tp_alloc_type(std::move(__a)), _M_map(), _M_map_size(0),
129981 using std::swap;
130044 return std::move(_M_impl);
130049 _Tp_alloc_type __sink __attribute((__unused__)) {std::move(__alloc)};
130054 _Deque_impl __ret{std::move(_M_get_Tp_allocator())};
130082 this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,
130141 template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
130164 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
130165 typedef std::reverse_iterator<iterator> reverse_iterator;
130220 { std::__uninitialized_copy_a(__x.begin(), __x.end(),
130225 : _Base(std::move(__x)) { }
130230 { std::__uninitialized_copy_a(__x.begin(), __x.end(),
130236 : _Base(std::move(__x), __a, __x.size())
130240 std::__uninitialized_move_a(__x.begin(), __x.end(),
130256 typename = std::_RequireInputIter<_InputIterator>>
130272 _M_move_assign1(std::move(__x), __always_equal{});
130288 typename = std::_RequireInputIter<_InputIterator>>
130550 { emplace_front(std::move(__x)); }
130573 { emplace_back(std::move(__x)); }
130616 { return emplace(__position, std::move(__x)); }
130631 typename = std::_RequireInputIter<_InputIterator>>
130697 typedef typename std::iterator_traits<_InputIterator>::
130705 std::input_iterator_tag);
130711 std::forward_iterator_tag);
130732 typedef typename std::iterator_traits<_InputIterator>::
130741 std::input_iterator_tag);
130747 std::forward_iterator_tag)
130749 const size_type __len = std::distance(__first, __last);
130753 std::advance(__mid, size());
130754 std::copy(__first, __mid, begin());
130758 _M_erase_at_end(std::copy(__first, __last, begin()));
130768 std::fill(begin(), end(), __val);
130774 std::fill(begin(), end(), __val);
130802 typedef typename std::iterator_traits<_InputIterator>::
130811 _InputIterator __last, std::input_iterator_tag);
130817 _ForwardIterator __last, std::forward_iterator_tag);
130861 const std::allocator<_Tp>&)
130958 std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
130969 _M_move_assign2(std::move(__x), __bool_constant<__move_storage>());
130979 deque __newobj(std::forward<_Args>(__args)...);
130998 _M_replace_map(std::move(__x));
131000 _M_get_Tp_allocator() = std::move(__alloc);
131012 _M_replace_map(std::move(__x), __x.get_allocator());
131018 this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
131019 std::__make_move_if_noexcept_iterator(__x.end()));
131031 && std::equal(__x.begin(), __x.end(), __y.begin()); }
131037 { return std::lexicographical_compare(__x.begin(), __x.end(),
131083 namespace std __attribute__ ((__visibility__ ("default")))
131099 std::__uninitialized_default_a(*__cur, *__cur + _S_buffer_size(),
131101 std::__uninitialized_default_a(this->_M_impl._M_finish._M_first,
131107 std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
131130 std::__alloc_on_copy(_M_get_Tp_allocator(),
131134 std::__alloc_on_copy(_M_get_Tp_allocator(),
131140 _M_erase_at_end(std::copy(__x.begin(), __x.end(),
131145 std::copy(__x.begin(), __mid, this->_M_impl._M_start);
131163 std::forward<_Args>(__args)...);
131167 _M_push_front_aux(std::forward<_Args>(__args)...);
131181 std::forward<_Args>(__args)...);
131185 _M_push_back_aux(std::forward<_Args>(__args)...);
131198 emplace_front(std::forward<_Args>(__args)...);
131203 emplace_back(std::forward<_Args>(__args)...);
131210 std::forward<_Args>(__args)...);
131250 std::move_backward(begin(), __position, __next);
131256 std::move(__next, end(), __position);
131281 std::move_backward(begin(), __first, __last);
131287 std::move(__last, end(), __first);
131299 std::input_iterator_tag)
131320 std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start,
131336 std::__uninitialized_fill_a(this->_M_impl._M_finish,
131363 std::__uninitialized_default_a(this->_M_impl._M_finish,
131392 return std::__shrink_to_fit_aux<deque>::_S_do_it(*this);
131407 std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(),
131409 std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first,
131415 std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
131426 std::input_iterator_tag)
131450 std::forward_iterator_tag)
131452 const size_type __n = std::distance(__first, __last);
131463 std::advance(__mid, _S_buffer_size());
131464 std::__uninitialized_copy_a(__first, __mid, *__cur_node,
131468 std::__uninitialized_copy_a(__first, __last,
131474 std::_Destroy(this->_M_impl._M_start,
131501 std::forward<_Args>(__args)...);
131539 std::forward<_Args>(__args)...);
131586 std::input_iterator_tag)
131587 { std::copy(__first, __last, std::inserter(*this, __pos)); }
131595 std::forward_iterator_tag)
131597 const size_type __n = std::distance(__first, __last);
131603 std::__uninitialized_copy_a(__first, __last, __new_start,
131619 std::__uninitialized_copy_a(__first, __last,
131642 value_type __x_copy(std::forward<_Args>(__args)...);
131653 push_front(std::move(front()));
131661 std::move(__front2, __pos1, __front1);
131665 push_back(std::move(back()));
131671 std::move_backward(__pos, __back2, __back1);
131673 *__pos = std::move(__x_copy);
131696 std::__uninitialized_move_a(this->_M_impl._M_start,
131700 std::move(__start_n, __pos, __old_start);
131701 std::fill(__pos - difference_type(__n), __pos, __x_copy);
131705 std::__uninitialized_move_fill(this->_M_impl._M_start,
131711 std::fill(__old_start, __pos, __x_copy);
131734 std::__uninitialized_move_a(__finish_n,
131739 std::move_backward(__pos, __finish_n, __old_finish);
131740 std::fill(__pos, __pos + difference_type(__n), __x_copy);
131744 std::__uninitialized_fill_move(this->_M_impl._M_finish,
131750 std::fill(__pos, __old_finish, __x_copy);
131783 std::__uninitialized_move_a(this->_M_impl._M_start,
131787 std::move(__start_n, __pos, __old_start);
131788 std::copy(__first, __last, __pos - difference_type(__n));
131793 std::advance(__mid, difference_type(__n) - __elemsbefore);
131794 std::__uninitialized_move_copy(this->_M_impl._M_start,
131799 std::copy(__mid, __last, __old_start);
131822 std::__uninitialized_move_a(__finish_n,
131827 std::move_backward(__pos, __finish_n, __old_finish);
131828 std::copy(__first, __last, __pos);
131833 std::advance(__mid, __elemsafter);
131834 std::__uninitialized_copy_move(__mid, __last, __pos,
131839 std::copy(__first, __mid, __pos);
131858 std::_Destroy(*__node, *__node + _S_buffer_size(),
131863 std::_Destroy(__first._M_cur, __first._M_last,
131865 std::_Destroy(__last._M_first, __last._M_cur,
131869 std::_Destroy(__first._M_cur, __last._M_cur,
131939 std::copy(this->_M_impl._M_start._M_node,
131943 std::copy_backward(this->_M_impl._M_start._M_node,
131950 + std::max(this->_M_impl._M_map_size,
131956 std::copy(this->_M_impl._M_start._M_node,
131980 std::fill(*__node, *__node + _Self::_S_buffer_size(), __value);
131984 std::fill(__first._M_cur, __first._M_last, __value);
131985 std::fill(__last._M_first, __last._M_cur, __value);
131988 std::fill(__first._M_cur, __last._M_cur, __value);
132004 = std::min(__len, std::min(__first._M_last - __first._M_cur,
132006 std::copy(__first._M_cur, __first._M_cur + __clen, __result._M_cur);
132043 const difference_type __clen = std::min(__len,
132044 std::min(__llen, __rlen));
132045 std::copy_backward(__lend - __clen, __lend, __rend);
132067 = std::min(__len, std::min(__first._M_last - __first._M_cur,
132069 std::move(__first._M_cur, __first._M_cur + __clen, __result._M_cur);
132106 const difference_type __clen = std::min(__len,
132107 std::min(__llen, __rlen));
132108 std::move_backward(__lend - __clen, __lend, __rend);
132130 namespace std __attribute__ ((__visibility__ ("default")))
132160 : _Tp_alloc_type(std::move(__a)),
132167 std::swap(_M_start, __x._M_start);
132168 std::swap(_M_finish, __x._M_finish);
132169 std::swap(_M_end_of_storage, __x._M_end_of_storage);
132204 : _M_impl(std::move(__a)) { }
132207 : _M_impl(std::move(__x._M_get_Tp_allocator()))
132255 template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
132278 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
132279 typedef std::reverse_iterator<iterator> reverse_iterator;
132325 std::__uninitialized_copy_a(__x.begin(), __x.end(),
132331 : _Base(std::move(__x)) { }
132337 std::__uninitialized_copy_a(__x.begin(), __x.end(),
132345 : _Base(std::move(__rv), __m)
132350 std::__uninitialized_move_a(__rv.begin(), __rv.end(),
132366 typename = std::_RequireInputIter<_InputIterator>>
132373 { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
132385 _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
132401 typename = std::_RequireInputIter<_InputIterator>>
132682 { emplace_back(std::move(__x)); }
132704 { return emplace(__position, std::move(__x)); }
132719 typename = std::_RequireInputIter<_InputIterator>>
132775 std::__uninitialized_copy_a(__first, __last, __result,
132802 typedef typename std::iterator_traits<_InputIterator>::
132811 _InputIterator __last, std::input_iterator_tag)
132825 _ForwardIterator __last, std::forward_iterator_tag)
132827 const size_type __n = std::distance(__first, __last);
132831 std::__uninitialized_copy_a(__first, __last,
132842 std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
132852 std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
132867 typedef typename std::iterator_traits<_InputIterator>::
132876 std::input_iterator_tag);
132882 std::forward_iterator_tag);
132901 typedef typename std::iterator_traits<_InputIterator>::
132910 _InputIterator __last, std::input_iterator_tag);
132916 _ForwardIterator __last, std::forward_iterator_tag);
132953 const size_type __len = size() + std::max(size(), __n);
132964 std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
132980 _M_move_assign(vector&& __x, std::true_type) noexcept
132985 std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
132991 _M_move_assign(vector&& __x, std::false_type)
132994 _M_move_assign(std::move(__x), std::true_type());
132999 this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
133000 std::__make_move_if_noexcept_iterator(__x.end()));
133013 typename std::pointer_traits<_Ptr>::element_type*
133015 { return empty() ? nullptr : std::__addressof(*__ptr); }
133028 && std::equal(__x.begin(), __x.end(), __y.begin())); }
133033 { return std::lexicographical_compare(__x.begin(), __x.end(),
133072 namespace std __attribute__ ((__visibility__ ("default")))
133146 : public std::iterator<std::random_access_iterator_tag, bool>
133411 std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0);
133445 : _Bit_alloc_type(std::move(__a)), _M_start(), _M_finish(),
133454 return std::__addressof(_M_end_of_storage[-1]) + 1;
133482 : _M_impl(std::move(__x._M_get_Bit_allocator()))
133526 namespace std __attribute__ ((__visibility__ ("default")))
133550 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
133551 typedef std::reverse_iterator<iterator> reverse_iterator;
133585 std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_addr(),
133598 : _Base(std::move(__x)) { }
133639 typename = std::_RequireInputIter<_InputIterator>>
133658 std::__alloc_on_copy(_M_get_Bit_allocator(),
133663 std::__alloc_on_copy(_M_get_Bit_allocator(),
133691 std::__alloc_on_move(_M_get_Bit_allocator(),
133726 typename = std::_RequireInputIter<_InputIterator>>
133890 std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
133891 std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
133892 std::swap(this->_M_impl._M_end_of_storage,
133925 typename = std::_RequireInputIter<_InputIterator>>
134020 _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
134021 return std::copy(const_iterator(__last._M_p, 0), __last,
134030 this->_M_impl._M_start = iterator(std::__addressof(*__q), 0);
134051 std::fill(this->_M_impl._M_start._M_p,
134060 std::__iterator_category(__first)); }
134065 std::input_iterator_tag)
134074 std::forward_iterator_tag)
134076 const size_type __n = std::distance(__first, __last);
134078 std::copy(__first, __last, this->_M_impl._M_start);
134092 { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
134099 std::fill(this->_M_impl._M_start._M_p,
134106 std::fill(this->_M_impl._M_start._M_p,
134114 std::input_iterator_tag)
134128 std::forward_iterator_tag)
134130 const size_type __len = std::distance(__first, __last);
134132 _M_erase_at_end(std::copy(__first, __last, begin()));
134136 std::advance(__mid, size());
134137 std::copy(__first, __mid, begin());
134158 std::__iterator_category(__first)); }
134166 _InputIterator __last, std::input_iterator_tag)
134178 _ForwardIterator __last, std::forward_iterator_tag);
134189 const size_type __len = size() + std::max(size(), __n);
134211 namespace std __attribute__ ((__visibility__ ("default")))
134218 struct hash<std::vector<bool, _Alloc>>
134219 : public __hash_base<size_t, std::vector<bool, _Alloc>>
134222 operator()(const std::vector<bool, _Alloc>&) const noexcept;
134233 namespace std __attribute__ ((__visibility__ ("default")))
134248 std::__make_move_if_noexcept_iterator(this->_M_impl._M_start),
134249 std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish));
134250 std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
134271 std::forward<_Args>(__args)...);
134275 _M_emplace_back_aux(std::forward<_Args>(__args)...);
134302 _M_insert_aux(__pos, std::move(__x_copy));
134319 std::move(__position + 1, end(), __position);
134333 std::move(__last, end(), __first);
134361 std::__alloc_on_copy(_M_get_Tp_allocator(),
134370 std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
134380 std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
134385 std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
134387 std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
134409 std::fill(begin(), end(), __val);
134411 std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
134416 _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
134424 std::input_iterator_tag)
134441 std::forward_iterator_tag)
134443 const size_type __len = std::distance(__first, __last);
134448 std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
134458 _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
134462 std::advance(__mid, size());
134463 std::copy(__first, __mid, this->_M_impl._M_start);
134465 std::__uninitialized_copy_a(__mid, __last,
134483 std::forward<_Args>(__args)...);
134488 std::forward<_Args>(__args)...);
134507 std::move(*(this->_M_impl._M_finish - 1)));
134513 std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1);
134519 *__position = _Tp(std::forward<_Args>(__args)...);
134538 std::forward<_Args>(__args)...);
134545 = std::__uninitialized_move_if_noexcept_a
134552 = std::__uninitialized_move_if_noexcept_a
134562 std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
134566 std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
134591 std::forward<_Args>(__args)...);
134595 = std::__uninitialized_move_if_noexcept_a
134606 std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
134610 std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
134636 std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
134641 std::move_backward(__position.base(), __old_finish - __n, __old_finish);
134643 std::fill(__position.base(), __position.base() + __n,
134649 std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
134653 std::__uninitialized_move_a(__position.base(), __old_finish,
134657 std::fill(__position.base(), __old_finish, __x_copy);
134670 std::__uninitialized_fill_n_a(__new_start + __elems_before,
134676 = std::__uninitialized_move_if_noexcept_a
134683 = std::__uninitialized_move_if_noexcept_a
134690 std::_Destroy(__new_start + __elems_before,
134694 std::_Destroy(__new_start, __new_finish,
134699 std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
134723 std::__uninitialized_default_n_a(this->_M_impl._M_finish,
134736 = std::__uninitialized_move_if_noexcept_a
134740 std::__uninitialized_default_n_a(__new_finish, __n,
134745 std::_Destroy(__new_start, __new_finish,
134750 std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
134769 return std::__shrink_to_fit_aux<vector>::_S_do_it(*this);
134778 _InputIterator __last, std::input_iterator_tag)
134792 _ForwardIterator __last, std::forward_iterator_tag)
134796 const size_type __n = std::distance(__first, __last);
134804 std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
134809 std::move_backward(__position.base(), __old_finish - __n, __old_finish);
134811 std::copy(__first, __last, __position);
134816 std::advance(__mid, __elems_after);
134817 std::__uninitialized_copy_a(__mid, __last,
134821 std::__uninitialized_move_a(__position.base(),
134826 std::copy(__first, __mid, __position);
134838 = std::__uninitialized_move_if_noexcept_a
134842 = std::__uninitialized_copy_a(__first, __last,
134846 = std::__uninitialized_move_if_noexcept_a
134852 std::_Destroy(__new_start, __new_finish,
134857 std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
134877 iterator __start(std::__addressof(*__q), 0);
134893 std::copy_backward(__position, end(),
134895 std::fill(__position, __position + difference_type(__n), __x);
134903 iterator __start(std::__addressof(*__q), 0);
134905 std::fill(__i, __i + difference_type(__n), __x);
134906 this->_M_impl._M_finish = std::copy(__position, end(),
134919 _ForwardIterator __last, std::forward_iterator_tag)
134923 size_type __n = std::distance(__first, __last);
134926 std::copy_backward(__position, end(),
134929 std::copy(__first, __last, __position);
134937 iterator __start(std::__addressof(*__q), 0);
134939 __i = std::copy(__first, __last, __i);
134940 this->_M_impl._M_finish = std::copy(__position, end(), __i);
134955 std::copy_backward(__position, this->_M_impl._M_finish,
134965 iterator __start(std::__addressof(*__q), 0);
134968 this->_M_impl._M_finish = std::copy(__position, end(), __i);
134981 std::copy(__position + 1, end(), __position);
134992 _M_erase_at_end(std::copy(__last, end(), __first));
135019 namespace std __attribute__ ((__visibility__ ("default")))
135025 hash<std::vector<bool, _Alloc>>::
135026 operator()(const std::vector<bool, _Alloc>& __b) const noexcept
135029 using std::_S_word_bit;
135030 using std::_Bit_type;
135036 __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength);
135048 __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash);
135050 __hash = std::_Hash_impl::hash(&__hiword, __clength);
135064 namespace std __attribute__ ((__visibility__ ("default")))
135110 : c(std::move(__c)) { }
135123 : c(std::move(__c), __a) { }
135131 : c(std::move(__q.c), __a) { }
135197 { c.push_back(std::move(__x)); }
135202 { c.emplace_back(std::forward<_Args>(__args)...); }
135216 using std::swap;
135297 { std::make_heap(c.begin(), c.end(), comp); }
135302 : c(std::move(__s)), comp(__x)
135303 { std::make_heap(c.begin(), c.end(), comp); }
135321 : c(std::move(__c), __a), comp(__x) { }
135329 : c(std::move(__q.c), __a), comp(std::move(__q.comp)) { }
135339 std::make_heap(c.begin(), c.end(), comp);
135346 : c(std::move(__s)), comp(__x)
135350 std::make_heap(c.begin(), c.end(), comp);
135381 std::push_heap(c.begin(), c.end(), comp);
135388 c.push_back(std::move(__x));
135389 std::push_heap(c.begin(), c.end(), comp);
135396 c.emplace_back(std::forward<_Args>(__args)...);
135397 std::push_heap(c.begin(), c.end(), comp);
135404 std::pop_heap(c.begin(), c.end(), comp);
135414 using std::swap;
135895 std::queue<nsCOMPtr<nsIRunnable>> mPromiseMicroTaskQueue;
135896 std::queue<nsCOMPtr<nsIRunnable>> mDebuggerPromiseMicroTaskQueue;
136022 std::queue<nsCOMPtr<nsIRunnable>>& GetPromiseMicroTaskQueue();
136023 std::queue<nsCOMPtr<nsIRunnable>>& GetDebuggerPromiseMicroTaskQueue();
146569 namespace std __attribute__ ((__visibility__ ("default")))
146758 std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));
146785 std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
147187 _M_check_initial_position(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
147291 bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
147297 std::basic_string<_CharT, _Traits, _Alloc>::npos,
147302 bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
147313 bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
147325 typename std::basic_string<_CharT>::size_type __n
147326 = std::basic_string<_CharT>::npos,
147333 if (__n == std::basic_string<_CharT>::npos)
147334 __n = std::char_traits<_CharT>::length(__str);
147335 _M_copy_from_ptr<_CharT, std::char_traits<_CharT>>(__str, __n, 0,
147512 std::basic_string<_CharT, _Traits, _Alloc>
147515 std::basic_string<_CharT, _Traits, _Alloc> __result;
147523 std::basic_string<_CharT, _Traits, _Alloc>
147526 std::basic_string<_CharT, _Traits, _Alloc> __result;
147534 std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
147536 { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
147541 std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
147544 std::allocator<_CharT> >(__zero, __one); }
147547 std::basic_string<_CharT, std::char_traits<_CharT>,
147548 std::allocator<_CharT> >
147551 return to_string<_CharT, std::char_traits<_CharT>,
147552 std::allocator<_CharT> >();
147556 std::basic_string<_CharT, std::char_traits<_CharT>,
147557 std::allocator<_CharT> >
147560 return to_string<_CharT, std::char_traits<_CharT>,
147561 std::allocator<_CharT> >(__zero, __one);
147564 std::basic_string<char, std::char_traits<char>, std::allocator<char> >
147567 return to_string<char, std::char_traits<char>,
147568 std::allocator<char> >();
147571 std::basic_string<char, std::char_traits<char>, std::allocator<char> >
147574 return to_string<char, std::char_traits<char>,
147575 std::allocator<char> >(__zero, __one);
147586 _M_copy_from_string(const std::basic_string<_CharT,
147594 _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>&,
147600 _M_copy_from_string(const std::basic_string<_CharT,
147606 _M_copy_to_string(std::basic_string<_CharT, _Traits,_Alloc>& __s) const
147690 const size_t __nbits = std::min(_Nb, std::min(__n, size_t(__len - __pos)));
147707 _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>& __s,
147744 std::basic_istream<_CharT, _Traits>&
147745 operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
147748 typedef std::basic_istream<_CharT, _Traits> __istream_type;
147751 std::basic_string<_CharT, _Traits> __tmp;
147812 std::basic_ostream<_CharT, _Traits>&
147813 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
147816 std::basic_string<_CharT, _Traits> __tmp;
147829 namespace std __attribute__ ((__visibility__ ("default")))
147836 struct hash<std::bitset<_Nb>>
147837 : public __hash_base<size_t, std::bitset<_Nb>>
147840 operator()(const std::bitset<_Nb>& __b) const noexcept
147843 return std::_Hash_impl::hash(__b._M_getdata(), __clength);
147848 struct hash<std::bitset<0>>
147849 : public __hash_base<size_t, std::bitset<0>>
147852 operator()(const std::bitset<0>&) const noexcept
150800 mutable std::bitset<eDeprecatedOperationCount> mDeprecationWarnedAbout;
150801 mutable std::bitset<eDocumentWarningCount> mDocWarningWarnedAbout;
151230 std::bitset<mozilla::eUseCounter_Count> mUseCounters;
151232 std::bitset<mozilla::eUseCounter_Count> mChildDocumentUseCounters;
151235 std::bitset<mozilla::eUseCounter_Count> mNotifiedPageForUseCounter;
152091 return std::min(mStackPointer,
158240 return std::max(mBaseMinFontSize, prefs->mMinimumFontSize);
159476 namespace std __attribute__ ((__visibility__ ("default")))
159524 : basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this))
159540 _M_string = std::move(__rhs._M_string);
159548 __xfer_bufptrs __l_st{*this, std::__addressof(__rhs)};
159553 std::swap(_M_mode, __rhs._M_mode);
159554 std::swap(_M_string, __rhs._M_string);
159710 _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string))
159763 : __istream_type(std::move(__rhs)),
159764 _M_stringbuf(std::move(__rhs._M_stringbuf))
159775 __istream_type::operator=(std::move(__rhs));
159776 _M_stringbuf = std::move(__rhs._M_stringbuf);
159858 : __ostream_type(std::move(__rhs)),
159859 _M_stringbuf(std::move(__rhs._M_stringbuf))
159870 __ostream_type::operator=(std::move(__rhs));
159871 _M_stringbuf = std::move(__rhs._M_stringbuf);
159953 : __iostream_type(std::move(__rhs)),
159954 _M_stringbuf(std::move(__rhs._M_stringbuf))
159965 __iostream_type::operator=(std::move(__rhs));
159966 _M_stringbuf = std::move(__rhs._M_stringbuf);
160038 namespace std __attribute__ ((__visibility__ ("default")))
160101 const __size_type __opt_len = std::max(__size_type(2 * __capacity),
160103 const __size_type __len = std::min(__opt_len, __max_size);
160421 static void OutputMessage(const std::string &aString,
160444 static void OutputMessage(const std::string &aString, int aLevel, bool aNoNewline);
160452 typedef mozilla::Tuple<int32_t,std::string,double> LoggingRecordEntry;
160456 typedef std::vector<LoggingRecordEntry> LoggingRecord;
160460 virtual void Log(const std::string &aString) = 0;
160462 virtual bool UpdateStringsVector(const std::string& aString) = 0;
160526 std::string str = mMessage.str();
160539 Log &operator <<(const std::string &aLogText) {
160635 mMessage << std::showbase << std::hex
160637 << std::noshowbase << std::dec;
160759 void WriteLog(const std::string &aString) {
160769 std::stringstream mMessage;
160793 explicit TreeLog(const std::string& aPrefix = "")
160807 mLog << '[' << mPrefix << "] " << std::string(mDepth * INDENT_PER_LEVEL, ' ');
160832 std::string mPrefix;
160843 static bool EndsInNewline(const std::string& aString) {
160852 return EndsInNewline(std::string(aString));
161037 scrollableRect.x = std::max(0.f,
161043 scrollableRect.y = std::max(0.f,
161070 size.width = std::min(size.width, mRootCompositionSize.width);
161071 size.height = std::min(size.height, mRootCompositionSize.height);
161079 scrollRange.width = std::max(scrollRange.width - scrollPortSize.width, 0.0f);
161080 scrollRange.height = std::max(scrollRange.height - scrollPortSize.height, 0.0f);
162335 return std::min(x, x + w);
162340 return std::min(y, y + h);
162345 return std::max(x, x + w);
162350 return std::max(y, y + h);
166470 typename = typename std::enable_if<std::is_enum<T>::value>::type>
166557 typename = typename std::enable_if<std::is_enum<T>::value>::type>
166569 typename = typename std::enable_if<std::is_enum<T>::value>::type>
168209 typename = typename std::enable_if<std::is_enum<T>::value>::type>
173934 aPadding.Side(side) = std::max(mPadding.ToLength(side), 0);
174134 ((aBorderWidth) == 0) ? 0 : std::max((mTwipsPerPixel), (aBorderWidth) / (mTwipsPerPixel) * (mTwipsPerPixel));
174357 typedef nsTArray<std::pair<nsString, nsString>> QuotePairArray;
175165 return std::max(mDuration, 0.0f) + mDelay;
176228 mColumnRuleWidth = ((aWidth) == 0) ? 0 : std::max((mTwipsPerPixel), (aWidth) / (mTwipsPerPixel) * (mTwipsPerPixel));