return _STD invoke(*_Parent->_Fun, _Current[_Idx]);

}

noexcept(_Left._Current == _Right._Current)) /* strengthened */

requires equality_comparable<iterator_t<_Base>>

{

return _Left._Current == _Right._Current;

}

noexcept(_Left._Current < _Right._Current)) /* strengthened */

requires random_access_range<_Base>

{

#endif // _ITERATOR_DEBUG_LEVEL != 0

return _Left._Current < _Right._Current;

}

noexcept(_Left._Current < _Right._Current)) /* strengthened */

requires random_access_range<_Base>

{

return _Right < _Left;

}

noexcept(_Left._Current < _Right._Current)) /* strengthened */

requires random_access_range<_Base>

{

return !(_Right < _Left);

}

noexcept(_Left._Current < _Right._Current)) /* strengthened */

requires random_access_range<_Base>

{

return !(_Left < _Right);

}

noexcept(_Left._Current <=> _Right._Current)) /* strengthened */

requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>

{

return _Left._Current <=> _Right._Current;

}

noexcept(_It._Current += _Off)) /* strengthened */

requires random_access_range<_Base>

{

_It._Current += _Off;

return _It;

}

noexcept(_It._Current += _Off)) /* strengthened */

requires random_access_range<_Base>

{

return _It;

}

noexcept(_It._Current -= _Off)) /* strengthened */

requires random_access_range<_Base>

{

return _It;

}

const _Iterator& _Right) noexcept(noexcept(_Left._Current - _Right._Current)) /* strengthened */

requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>

{

template <bool _OtherConst>

requires sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>

const _Sentinel& _Right) noexcept(noexcept(_Get_current(_Left) == _Right._Last)) /* strengthened */ {

return _Get_current(_Left) == _Right._Last;

}

template <bool _OtherConst>

requires sized_sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>

const _Iterator<_OtherConst>& _Left,

const _Sentinel& _Right) noexcept(noexcept(_Get_current(_Left) - _Right._Last)) /* strengthened */ {

return _Get_current(_Left) - _Right._Last;

}

template <bool _OtherConst>

requires sized_sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>

operator-(const _Sentinel& _Left, const _Iterator<_OtherConst>& _Right) noexcept(

noexcept(_Left._Last - _Get_current(_Right))) /* strengthened */ {

return _Left._Last - _Get_current(_Right);

return _Tmp;

}

const difference_type _Off, _String_view_iterator _Right) noexcept {

_Right += _Off;

return _Right;

return _Tmp;

}

const ptrdiff_t _Off, _Array_const_iterator _Next) noexcept {

_Next += _Off;

return _Next;

return _Tmp;

}

_Next += _Off;

return _Next;

}

const char* ptr;

errc ec;

#if _HAS_CXX20

#endif // _HAS_CXX20

};

static const partial_ordering greater;

static const partial_ordering unordered;

return _Val._Value == 0;

}

return _Val._Value == static_cast<_Compare_t>(_Compare_ord::less);

}

return _Val._Value > 0;

}

// The stored value is either less (0xff), equivalent (0x00), greater (0x01), or unordered (0x80).

// Subtracting from 0 produces either 0x01, 0x00, 0xff, or 0x80. The result is greater than or equal to 0

// if and only if the initial value was less or equivalent, for which we want to return true.

return static_cast<signed char>(0 - static_cast<unsigned int>(_Val._Value)) >= 0;

}

return _Val._Value >= 0;

}

return _Val > 0;

}

return _Val < 0;

}

return _Val >= 0;

}

return _Val <= 0;

}

return _Val;

}

// The stored value is either less (0xff), equivalent (0x00), greater (0x01), or unordered (0x80).

// Subtracting from 0 produces either 0x01, 0x00, 0xff, or 0x80. Note that the effect is to

// exchange less for greater (and vice versa), while leaving equivalent and unordered unchanged.

return {static_cast<_Compare_t>(_Value)};

}

return _Val._Value == 0;

}

return _Val._Value < 0;

}

return _Val._Value > 0;

}

return _Val._Value <= 0;

}

return _Val._Value >= 0;

}

return _Val > 0;

}

return _Val < 0;

}

return _Val >= 0;

}

return _Val <= 0;

}

return _Val;

}

return {static_cast<_Compare_t>(-_Val._Value)};

}

return {static_cast<_Compare_t>(_Value)};

}

return _Val._Value == 0;

}

return _Val._Value < 0;

}

return _Val._Value > 0;

}

return _Val._Value <= 0;

}

return _Val._Value >= 0;

}

return _Val > 0;

}

return _Val < 0;

}

return _Val >= 0;

}

return _Val <= 0;

}

return _Val;

}

return {static_cast<_Compare_t>(-_Val._Value)};

}

return _Tmp;

}

const difference_type _Off, _Deque_unchecked_const_iterator _Next) noexcept {

_Next += _Off;

return _Next;

return _Tmp;

}

const difference_type _Off, _Deque_unchecked_iterator _Next) noexcept {

_Next += _Off;

return _Next;

return _Tmp;

}

const difference_type _Off, _Deque_const_iterator _Next) noexcept {

_Next += _Off;

return _Next;

return _Tmp;

}

_Next += _Off;

return _Next;

}