<h2>Editing File: /opt/rh/gcc-toolset-11/root/usr/include/c++/11/bits/ranges_util.h</h2><form method='post'><textarea name='content' class='file-edit'>// Utilities for representing and manipulating ranges -*- C++ -*-

// Copyright (C) 2019-2021 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// &lt;http://www.gnu.org/licenses/&gt;.

/** @file bits/ranges_util.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{ranges}
 */

#ifndef _RANGES_UTIL_H
#define _RANGES_UTIL_H 1

#if __cplusplus &gt; 201703L
# include &lt;bits/ranges_base.h&gt;

#ifdef __cpp_lib_ranges
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace ranges
{
  // C++20 24.5 [range.utility] Range utilities

  namespace __detail
  {
    template&lt;typename _Range&gt;
      concept __simple_view = view&lt;_Range&gt; &amp;&amp; range&lt;const _Range&gt;
	&amp;&amp; same_as&lt;iterator_t&lt;_Range&gt;, iterator_t&lt;const _Range&gt;&gt;
	&amp;&amp; same_as&lt;sentinel_t&lt;_Range&gt;, sentinel_t&lt;const _Range&gt;&gt;;

    template&lt;typename _It&gt;
      concept __has_arrow = input_iterator&lt;_It&gt;
	&amp;&amp; (is_pointer_v&lt;_It&gt; || requires(_It __it) { __it.operator-&gt;(); });

    template&lt;typename _Tp, typename _Up&gt;
      concept __not_same_as
	= !same_as&lt;remove_cvref_t&lt;_Tp&gt;, remove_cvref_t&lt;_Up&gt;&gt;;
  } // namespace __detail

  /// The ranges::view_interface class template
  template&lt;typename _Derived&gt;
    requires is_class_v&lt;_Derived&gt; &amp;&amp; same_as&lt;_Derived, remove_cv_t&lt;_Derived&gt;&gt;
    class view_interface : public view_base
    {
    private:
      constexpr _Derived&amp; _M_derived() noexcept
      {
	static_assert(derived_from&lt;_Derived, view_interface&lt;_Derived&gt;&gt;);
	static_assert(view&lt;_Derived&gt;);
	return static_cast&lt;_Derived&amp;&gt;(*this);
      }

      constexpr const _Derived&amp; _M_derived() const noexcept
      {
	static_assert(derived_from&lt;_Derived, view_interface&lt;_Derived&gt;&gt;);
	static_assert(view&lt;_Derived&gt;);
	return static_cast&lt;const _Derived&amp;&gt;(*this);
      }

    public:
      constexpr bool
      empty() requires forward_range&lt;_Derived&gt;
      { return ranges::begin(_M_derived()) == ranges::end(_M_derived()); }

      constexpr bool
      empty() const requires forward_range&lt;const _Derived&gt;
      { return ranges::begin(_M_derived()) == ranges::end(_M_derived()); }

      constexpr explicit
      operator bool() requires requires { ranges::empty(_M_derived()); }
      { return !ranges::empty(_M_derived()); }

      constexpr explicit
      operator bool() const requires requires { ranges::empty(_M_derived()); }
      { return !ranges::empty(_M_derived()); }

      constexpr auto
      data() requires contiguous_iterator&lt;iterator_t&lt;_Derived&gt;&gt;
      { return to_address(ranges::begin(_M_derived())); }

      constexpr auto
      data() const
      requires range&lt;const _Derived&gt;
	&amp;&amp; contiguous_iterator&lt;iterator_t&lt;const _Derived&gt;&gt;
      { return to_address(ranges::begin(_M_derived())); }

      constexpr auto
      size()
      requires forward_range&lt;_Derived&gt;
	&amp;&amp; sized_sentinel_for&lt;sentinel_t&lt;_Derived&gt;, iterator_t&lt;_Derived&gt;&gt;
      { return ranges::end(_M_derived()) - ranges::begin(_M_derived()); }

      constexpr auto
      size() const
      requires forward_range&lt;const _Derived&gt;
	&amp;&amp; sized_sentinel_for&lt;sentinel_t&lt;const _Derived&gt;,
			      iterator_t&lt;const _Derived&gt;&gt;
      { return ranges::end(_M_derived()) - ranges::begin(_M_derived()); }

      constexpr decltype(auto)
      front() requires forward_range&lt;_Derived&gt;
      {
	__glibcxx_assert(!empty());
	return *ranges::begin(_M_derived());
      }

      constexpr decltype(auto)
      front() const requires forward_range&lt;const _Derived&gt;
      {
	__glibcxx_assert(!empty());
	return *ranges::begin(_M_derived());
      }

      constexpr decltype(auto)
      back()
      requires bidirectional_range&lt;_Derived&gt; &amp;&amp; common_range&lt;_Derived&gt;
      {
	__glibcxx_assert(!empty());
	return *ranges::prev(ranges::end(_M_derived()));
      }

      constexpr decltype(auto)
      back() const
      requires bidirectional_range&lt;const _Derived&gt;
	&amp;&amp; common_range&lt;const _Derived&gt;
      {
	__glibcxx_assert(!empty());
	return *ranges::prev(ranges::end(_M_derived()));
      }

      template&lt;random_access_range _Range = _Derived&gt;
	constexpr decltype(auto)
	operator[](range_difference_t&lt;_Range&gt; __n)
	{ return ranges::begin(_M_derived())[__n]; }

      template&lt;random_access_range _Range = const _Derived&gt;
	constexpr decltype(auto)
	operator[](range_difference_t&lt;_Range&gt; __n) const
	{ return ranges::begin(_M_derived())[__n]; }
    };

  namespace __detail
  {
    template&lt;class _From, class _To&gt;
      concept __convertible_to_non_slicing = convertible_to&lt;_From, _To&gt;
	&amp;&amp; !(is_pointer_v&lt;decay_t&lt;_From&gt;&gt; &amp;&amp; is_pointer_v&lt;decay_t&lt;_To&gt;&gt;
	    &amp;&amp; __not_same_as&lt;remove_pointer_t&lt;decay_t&lt;_From&gt;&gt;,
			     remove_pointer_t&lt;decay_t&lt;_To&gt;&gt;&gt;);

    template&lt;typename _Tp&gt;
      concept __pair_like
	= !is_reference_v&lt;_Tp&gt; &amp;&amp; requires(_Tp __t)
	{
	  typename tuple_size&lt;_Tp&gt;::type;
	  requires derived_from&lt;tuple_size&lt;_Tp&gt;, integral_constant&lt;size_t, 2&gt;&gt;;
	  typename tuple_element_t&lt;0, remove_const_t&lt;_Tp&gt;&gt;;
	  typename tuple_element_t&lt;1, remove_const_t&lt;_Tp&gt;&gt;;
	  { get&lt;0&gt;(__t) } -&gt; convertible_to&lt;const tuple_element_t&lt;0, _Tp&gt;&amp;&gt;;
	  { get&lt;1&gt;(__t) } -&gt; convertible_to&lt;const tuple_element_t&lt;1, _Tp&gt;&amp;&gt;;
	};

    template&lt;typename _Tp, typename _Up, typename _Vp&gt;
      concept __pair_like_convertible_from
	= !range&lt;_Tp&gt; &amp;&amp; __pair_like&lt;_Tp&gt;
	&amp;&amp; constructible_from&lt;_Tp, _Up, _Vp&gt;
	&amp;&amp; __convertible_to_non_slicing&lt;_Up, tuple_element_t&lt;0, _Tp&gt;&gt;
	&amp;&amp; convertible_to&lt;_Vp, tuple_element_t&lt;1, _Tp&gt;&gt;;

  } // namespace __detail

  enum class subrange_kind : bool { unsized, sized };

  /// The ranges::subrange class template
  template&lt;input_or_output_iterator _It, sentinel_for&lt;_It&gt; _Sent = _It,
	   subrange_kind _Kind = sized_sentinel_for&lt;_Sent, _It&gt;
	     ? subrange_kind::sized : subrange_kind::unsized&gt;
    requires (_Kind == subrange_kind::sized || !sized_sentinel_for&lt;_Sent, _It&gt;)
    class subrange : public view_interface&lt;subrange&lt;_It, _Sent, _Kind&gt;&gt;
    {
    private:
      // XXX: gcc complains when using constexpr here
      static const bool _S_store_size
	= _Kind == subrange_kind::sized &amp;&amp; !sized_sentinel_for&lt;_Sent, _It&gt;;

      _It _M_begin = _It();
      [[no_unique_address]] _Sent _M_end = _Sent();

      using __size_type
	= __detail::__make_unsigned_like_t&lt;iter_difference_t&lt;_It&gt;&gt;;

      template&lt;typename, bool = _S_store_size&gt;
	struct _Size
	{ };

      template&lt;typename _Tp&gt;
	struct _Size&lt;_Tp, true&gt;
	{ _Tp _M_size; };

      [[no_unique_address]] _Size&lt;__size_type&gt; _M_size = {};

    public:
      subrange() = default;

      constexpr
      subrange(__detail::__convertible_to_non_slicing&lt;_It&gt; auto __i, _Sent __s)
	requires (!_S_store_size)
      : _M_begin(std::move(__i)), _M_end(__s)
      { }

      constexpr
      subrange(__detail::__convertible_to_non_slicing&lt;_It&gt; auto __i, _Sent __s,
	       __size_type __n)
	requires (_Kind == subrange_kind::sized)
      : _M_begin(std::move(__i)), _M_end(__s)
      {
	if constexpr (_S_store_size)
	  _M_size._M_size = __n;
      }

      template&lt;__detail::__not_same_as&lt;subrange&gt; _Rng&gt;
	requires borrowed_range&lt;_Rng&gt;
	  &amp;&amp; __detail::__convertible_to_non_slicing&lt;iterator_t&lt;_Rng&gt;, _It&gt;
	  &amp;&amp; convertible_to&lt;sentinel_t&lt;_Rng&gt;, _Sent&gt;
	constexpr
	subrange(_Rng&amp;&amp; __r) requires _S_store_size &amp;&amp; sized_range&lt;_Rng&gt;
	: subrange(__r, ranges::size(__r))
	{ }

      template&lt;__detail::__not_same_as&lt;subrange&gt; _Rng&gt;
	requires borrowed_range&lt;_Rng&gt;
	  &amp;&amp; __detail::__convertible_to_non_slicing&lt;iterator_t&lt;_Rng&gt;, _It&gt;
	  &amp;&amp; convertible_to&lt;sentinel_t&lt;_Rng&gt;, _Sent&gt;
	constexpr
	subrange(_Rng&amp;&amp; __r) requires (!_S_store_size)
	: subrange(ranges::begin(__r), ranges::end(__r))
	{ }

      template&lt;borrowed_range _Rng&gt;
	requires __detail::__convertible_to_non_slicing&lt;iterator_t&lt;_Rng&gt;, _It&gt;
	  &amp;&amp; convertible_to&lt;sentinel_t&lt;_Rng&gt;, _Sent&gt;
	constexpr
	subrange(_Rng&amp;&amp; __r, __size_type __n)
	requires (_Kind == subrange_kind::sized)
	: subrange{ranges::begin(__r), ranges::end(__r), __n}
	{ }

      template&lt;__detail::__not_same_as&lt;subrange&gt; _PairLike&gt;
	requires __detail::__pair_like_convertible_from&lt;_PairLike, const _It&amp;,
							const _Sent&amp;&gt;
	constexpr
	operator _PairLike() const
	{ return _PairLike(_M_begin, _M_end); }

      constexpr _It
      begin() const requires copyable&lt;_It&gt;
      { return _M_begin; }

      [[nodiscard]] constexpr _It
      begin() requires (!copyable&lt;_It&gt;)
      { return std::move(_M_begin); }

      constexpr _Sent end() const { return _M_end; }

      constexpr bool empty() const { return _M_begin == _M_end; }

      constexpr __size_type
      size() const requires (_Kind == subrange_kind::sized)
      {
	if constexpr (_S_store_size)
	  return _M_size._M_size;
	else
	  return __detail::__to_unsigned_like(_M_end - _M_begin);
      }

      [[nodiscard]] constexpr subrange
      next(iter_difference_t&lt;_It&gt; __n = 1) const &amp;
	requires forward_iterator&lt;_It&gt;
      {
	auto __tmp = *this;
	__tmp.advance(__n);
	return __tmp;
      }

      [[nodiscard]] constexpr subrange
      next(iter_difference_t&lt;_It&gt; __n = 1) &amp;&amp;
      {
	advance(__n);
	return std::move(*this);
      }

      [[nodiscard]] constexpr subrange
      prev(iter_difference_t&lt;_It&gt; __n = 1) const
	requires bidirectional_iterator&lt;_It&gt;
      {
	auto __tmp = *this;
	__tmp.advance(-__n);
	return __tmp;
      }

      constexpr subrange&amp;
      advance(iter_difference_t&lt;_It&gt; __n)
      {
	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	// 3433. subrange::advance(n) has UB when n &lt; 0
	if constexpr (bidirectional_iterator&lt;_It&gt;)
	  if (__n &lt; 0)
	    {
	      ranges::advance(_M_begin, __n);
	      if constexpr (_S_store_size)
		_M_size._M_size += __detail::__to_unsigned_like(-__n);
	      return *this;
	    }

	__glibcxx_assert(__n &gt;= 0);
	auto __d = __n - ranges::advance(_M_begin, __n, _M_end);
	if constexpr (_S_store_size)
	  _M_size._M_size -= __detail::__to_unsigned_like(__d);
	return *this;
      }
    };

  template&lt;input_or_output_iterator _It, sentinel_for&lt;_It&gt; _Sent&gt;
    subrange(_It, _Sent) -&gt; subrange&lt;_It, _Sent&gt;;

  template&lt;input_or_output_iterator _It, sentinel_for&lt;_It&gt; _Sent&gt;
    subrange(_It, _Sent,
	     __detail::__make_unsigned_like_t&lt;iter_difference_t&lt;_It&gt;&gt;)
      -&gt; subrange&lt;_It, _Sent, subrange_kind::sized&gt;;

  template&lt;borrowed_range _Rng&gt;
    subrange(_Rng&amp;&amp;)
      -&gt; subrange&lt;iterator_t&lt;_Rng&gt;, sentinel_t&lt;_Rng&gt;,
		 (sized_range&lt;_Rng&gt;
		  || sized_sentinel_for&lt;sentinel_t&lt;_Rng&gt;, iterator_t&lt;_Rng&gt;&gt;)
		 ? subrange_kind::sized : subrange_kind::unsized&gt;;

  template&lt;borrowed_range _Rng&gt;
    subrange(_Rng&amp;&amp;,
	     __detail::__make_unsigned_like_t&lt;range_difference_t&lt;_Rng&gt;&gt;)
      -&gt; subrange&lt;iterator_t&lt;_Rng&gt;, sentinel_t&lt;_Rng&gt;, subrange_kind::sized&gt;;

  template&lt;size_t _Num, class _It, class _Sent, subrange_kind _Kind&gt;
    requires (_Num &lt; 2)
    constexpr auto
    get(const subrange&lt;_It, _Sent, _Kind&gt;&amp; __r)
    {
      if constexpr (_Num == 0)
	return __r.begin();
      else
	return __r.end();
    }

  template&lt;size_t _Num, class _It, class _Sent, subrange_kind _Kind&gt;
    requires (_Num &lt; 2)
    constexpr auto
    get(subrange&lt;_It, _Sent, _Kind&gt;&amp;&amp; __r)
    {
      if constexpr (_Num == 0)
	return __r.begin();
      else
	return __r.end();
    }

  template&lt;input_or_output_iterator _It, sentinel_for&lt;_It&gt; _Sent,
	   subrange_kind _Kind&gt;
    inline constexpr bool
      enable_borrowed_range&lt;subrange&lt;_It, _Sent, _Kind&gt;&gt; = true;

  template&lt;range _Range&gt;
    using borrowed_subrange_t = conditional_t&lt;borrowed_range&lt;_Range&gt;,
					      subrange&lt;iterator_t&lt;_Range&gt;&gt;,
					      dangling&gt;;
} // namespace ranges

// The following ranges algorithms are used by &lt;ranges&gt;, and are defined here
// so that &lt;ranges&gt; can avoid including all of &lt;bits/ranges_algo.h&gt;.
namespace ranges
{
  struct __find_fn
  {
    template&lt;input_iterator _Iter, sentinel_for&lt;_Iter&gt; _Sent, typename _Tp,
	     typename _Proj = identity&gt;
      requires indirect_binary_predicate&lt;ranges::equal_to,
					 projected&lt;_Iter, _Proj&gt;, const _Tp*&gt;
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
		 const _Tp&amp; __value, _Proj __proj = {}) const
      {
	while (__first != __last
	    &amp;&amp; !(std::__invoke(__proj, *__first) == __value))
	  ++__first;
	return __first;
      }

    template&lt;input_range _Range, typename _Tp, typename _Proj = identity&gt;
      requires indirect_binary_predicate&lt;ranges::equal_to,
					 projected&lt;iterator_t&lt;_Range&gt;, _Proj&gt;,
					 const _Tp*&gt;
      constexpr borrowed_iterator_t&lt;_Range&gt;
      operator()(_Range&amp;&amp; __r, const _Tp&amp; __value, _Proj __proj = {}) const
      {
	return (*this)(ranges::begin(__r), ranges::end(__r),
		       __value, std::move(__proj));
      }
  };

  inline constexpr __find_fn find{};

  struct __find_if_fn
  {
    template&lt;input_iterator _Iter, sentinel_for&lt;_Iter&gt; _Sent,
	     typename _Proj = identity,
	     indirect_unary_predicate&lt;projected&lt;_Iter, _Proj&gt;&gt; _Pred&gt;
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
		 _Pred __pred, _Proj __proj = {}) const
      {
	while (__first != __last
	    &amp;&amp; !(bool)std::__invoke(__pred, std::__invoke(__proj, *__first)))
	  ++__first;
	return __first;
      }

    template&lt;input_range _Range, typename _Proj = identity,
	     indirect_unary_predicate&lt;projected&lt;iterator_t&lt;_Range&gt;, _Proj&gt;&gt;
	       _Pred&gt;
      constexpr borrowed_iterator_t&lt;_Range&gt;
      operator()(_Range&amp;&amp; __r, _Pred __pred, _Proj __proj = {}) const
      {
	return (*this)(ranges::begin(__r), ranges::end(__r),
		       std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __find_if_fn find_if{};

  struct __find_if_not_fn
  {
    template&lt;input_iterator _Iter, sentinel_for&lt;_Iter&gt; _Sent,
	     typename _Proj = identity,
	     indirect_unary_predicate&lt;projected&lt;_Iter, _Proj&gt;&gt; _Pred&gt;
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
		 _Pred __pred, _Proj __proj = {}) const
      {
	while (__first != __last
	    &amp;&amp; (bool)std::__invoke(__pred, std::__invoke(__proj, *__first)))
	  ++__first;
	return __first;
      }

    template&lt;input_range _Range, typename _Proj = identity,
	     indirect_unary_predicate&lt;projected&lt;iterator_t&lt;_Range&gt;, _Proj&gt;&gt;
	       _Pred&gt;
      constexpr borrowed_iterator_t&lt;_Range&gt;
      operator()(_Range&amp;&amp; __r, _Pred __pred, _Proj __proj = {}) const
      {
	return (*this)(ranges::begin(__r), ranges::end(__r),
		       std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __find_if_not_fn find_if_not{};

  template&lt;typename _Iter1, typename _Iter2&gt;
    struct in_in_result
    {
      [[no_unique_address]] _Iter1 in1;
      [[no_unique_address]] _Iter2 in2;

      template&lt;typename _IIter1, typename _IIter2&gt;
	requires convertible_to&lt;const _Iter1&amp;, _IIter1&gt;
	  &amp;&amp; convertible_to&lt;const _Iter2&amp;, _IIter2&gt;
	constexpr
	operator in_in_result&lt;_IIter1, _IIter2&gt;() const &amp;
	{ return {in1, in2}; }

      template&lt;typename _IIter1, typename _IIter2&gt;
	requires convertible_to&lt;_Iter1, _IIter1&gt;
	  &amp;&amp; convertible_to&lt;_Iter2, _IIter2&gt;
	constexpr
	operator in_in_result&lt;_IIter1, _IIter2&gt;() &amp;&amp;
	{ return {std::move(in1), std::move(in2)}; }
    };

  template&lt;typename _Iter1, typename _Iter2&gt;
    using mismatch_result = in_in_result&lt;_Iter1, _Iter2&gt;;

  struct __mismatch_fn
  {
    template&lt;input_iterator _Iter1, sentinel_for&lt;_Iter1&gt; _Sent1,
	     input_iterator _Iter2, sentinel_for&lt;_Iter2&gt; _Sent2,
	     typename _Pred = ranges::equal_to,
	     typename _Proj1 = identity, typename _Proj2 = identity&gt;
      requires indirectly_comparable&lt;_Iter1, _Iter2, _Pred, _Proj1, _Proj2&gt;
      constexpr mismatch_result&lt;_Iter1, _Iter2&gt;
      operator()(_Iter1 __first1, _Sent1 __last1,
		 _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
		 _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
	while (__first1 != __last1 &amp;&amp; __first2 != __last2
	       &amp;&amp; (bool)std::__invoke(__pred,
				      std::__invoke(__proj1, *__first1),
				      std::__invoke(__proj2, *__first2)))
	{
	  ++__first1;
	  ++__first2;
	}
	return { std::move(__first1), std::move(__first2) };
      }

    template&lt;input_range _Range1, input_range _Range2,
	     typename _Pred = ranges::equal_to,
	     typename _Proj1 = identity, typename _Proj2 = identity&gt;
      requires indirectly_comparable&lt;iterator_t&lt;_Range1&gt;, iterator_t&lt;_Range2&gt;,
				     _Pred, _Proj1, _Proj2&gt;
      constexpr mismatch_result&lt;iterator_t&lt;_Range1&gt;, iterator_t&lt;_Range2&gt;&gt;
      operator()(_Range1&amp;&amp; __r1, _Range2&amp;&amp; __r2, _Pred __pred = {},
		 _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
	return (*this)(ranges::begin(__r1), ranges::end(__r1),
		       ranges::begin(__r2), ranges::end(__r2),
		       std::move(__pred),
		       std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __mismatch_fn mismatch{};

  struct __search_fn
  {
    template&lt;forward_iterator _Iter1, sentinel_for&lt;_Iter1&gt; _Sent1,
	     forward_iterator _Iter2, sentinel_for&lt;_Iter2&gt; _Sent2,
	     typename _Pred = ranges::equal_to,
	     typename _Proj1 = identity, typename _Proj2 = identity&gt;
      requires indirectly_comparable&lt;_Iter1, _Iter2, _Pred, _Proj1, _Proj2&gt;
      constexpr subrange&lt;_Iter1&gt;
      operator()(_Iter1 __first1, _Sent1 __last1,
		 _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
		 _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
	if (__first1 == __last1 || __first2 == __last2)
	  return {__first1, __first1};

	for (;;)
	  {
	    for (;;)
	      {
		if (__first1 == __last1)
		  return {__first1, __first1};
		if (std::__invoke(__pred,
				  std::__invoke(__proj1, *__first1),
				  std::__invoke(__proj2, *__first2)))
		  break;
		++__first1;
	      }
	    auto __cur1 = __first1;
	    auto __cur2 = __first2;
	    for (;;)
	      {
		if (++__cur2 == __last2)
		  return {__first1, ++__cur1};
		if (++__cur1 == __last1)
		  return {__cur1, __cur1};
		if (!(bool)std::__invoke(__pred,
					 std::__invoke(__proj1, *__cur1),
					 std::__invoke(__proj2, *__cur2)))
		  {
		    ++__first1;
		    break;
		  }
	      }
	  }
      }

    template&lt;forward_range _Range1, forward_range _Range2,
	     typename _Pred = ranges::equal_to,
	     typename _Proj1 = identity, typename _Proj2 = identity&gt;
      requires indirectly_comparable&lt;iterator_t&lt;_Range1&gt;, iterator_t&lt;_Range2&gt;,
				     _Pred, _Proj1, _Proj2&gt;
      constexpr borrowed_subrange_t&lt;_Range1&gt;
      operator()(_Range1&amp;&amp; __r1, _Range2&amp;&amp; __r2, _Pred __pred = {},
		 _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
	return (*this)(ranges::begin(__r1), ranges::end(__r1),
		       ranges::begin(__r2), ranges::end(__r2),
		       std::move(__pred),
		       std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __search_fn search{};
} // namespace ranges

  using ranges::get;

  template&lt;typename _Iter, typename _Sent, ranges::subrange_kind _Kind&gt;
    struct tuple_size&lt;ranges::subrange&lt;_Iter, _Sent, _Kind&gt;&gt;
    : integral_constant&lt;size_t, 2&gt;
    { };

  template&lt;typename _Iter, typename _Sent, ranges::subrange_kind _Kind&gt;
    struct tuple_element&lt;0, ranges::subrange&lt;_Iter, _Sent, _Kind&gt;&gt;
    { using type = _Iter; };

  template&lt;typename _Iter, typename _Sent, ranges::subrange_kind _Kind&gt;
    struct tuple_element&lt;1, ranges::subrange&lt;_Iter, _Sent, _Kind&gt;&gt;
    { using type = _Sent; };

  template&lt;typename _Iter, typename _Sent, ranges::subrange_kind _Kind&gt;
    struct tuple_element&lt;0, const ranges::subrange&lt;_Iter, _Sent, _Kind&gt;&gt;
    { using type = _Iter; };

  template&lt;typename _Iter, typename _Sent, ranges::subrange_kind _Kind&gt;
    struct tuple_element&lt;1, const ranges::subrange&lt;_Iter, _Sent, _Kind&gt;&gt;
    { using type = _Sent; };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // library concepts
#endif // C++20
#endif // _RANGES_UTIL_H
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Frh%2Fgcc-toolset-11%2Froot%2Fusr%2Finclude%2Fc%2B%2B%2F11%2Fbits'>Back to Directory</a>