{Ninja-Shell}

Filename: //usr/include/c++/10///ranges

// <ranges> -*- C++ -*-

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

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

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

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

/** @file include/ranges
 *  This is a Standard C++ Library header.
 *  @ingroup concepts
 */

#ifndef _GLIBCXX_RANGES
#define _GLIBCXX_RANGES 1

#if __cplusplus > 201703L

#pragma GCC system_header

#include <concepts>

#if __cpp_lib_concepts

#include <bits/refwrap.h>
#include <compare>
#include <initializer_list>
#include <iterator>
#include <optional>
#include <tuple>

/**
 * @defgroup ranges Ranges
 *
 * Components for dealing with ranges of elements.
 */

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace ranges
{
  // [range.range] The range concept.
  // [range.sized] The sized_range concept.
  // Defined in <bits/range_access.h>

// [range.refinements]
  // Defined in <bits/range_access.h>

struct view_base { };

template<typename _Tp>
    inline constexpr bool enable_view = derived_from<_Tp, view_base>;

template<typename _Tp>
    concept view
      = range<_Tp> && movable<_Tp> && default_initializable<_Tp>
	&& enable_view<_Tp>;

/// A range which can be safely converted to a view.
  template<typename _Tp>
    concept viewable_range = range<_Tp>
      && (borrowed_range<_Tp> || view<remove_cvref_t<_Tp>>);

namespace __detail
  {
    template<typename _Range>
      concept __simple_view = view<_Range> && range<const _Range>
	&& same_as<iterator_t<_Range>, iterator_t<const _Range>>
	&& same_as<sentinel_t<_Range>, sentinel_t<const _Range>>;

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

template<typename _Tp, typename _Up>
      concept __not_same_as
	= !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
  } // namespace __detail

template<typename _Derived>
    requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
    class view_interface : public view_base
    {
    private:
      constexpr _Derived& _M_derived() noexcept
      {
	static_assert(derived_from<_Derived, view_interface<_Derived>>);
	static_assert(view<_Derived>);
	return static_cast<_Derived&>(*this);
      }

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

public:
      constexpr bool
      empty() requires forward_range<_Derived>
      { return ranges::begin(_M_derived()) == ranges::end(_M_derived()); }

constexpr bool
      empty() const requires forward_range<const _Derived>
      { 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<iterator_t<_Derived>>
      { return to_address(ranges::begin(_M_derived())); }

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

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

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

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

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

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

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

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

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

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

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

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

template<typename _Tp>
      concept __iterator_sentinel_pair
	= !range<_Tp> && __pair_like<_Tp>
	&& sentinel_for<tuple_element_t<1, _Tp>, tuple_element_t<0, _Tp>>;

} // namespace __detail

enum class subrange_kind : bool { unsized, sized };

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

_It _M_begin = _It();
      _Sent _M_end = _Sent();

template<typename, bool = _S_store_size>
	struct _Size
	{ };

template<typename _Tp>
	struct _Size<_Tp, true>
	{ __detail::__make_unsigned_like_t<_Tp> _M_size; };

[[no_unique_address]] _Size<iter_difference_t<_It>> _M_size = {};

public:
      subrange() = default;

constexpr
      subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s)
	requires (!_S_store_size)
      : _M_begin(std::move(__i)), _M_end(__s)
      { }

constexpr
      subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s,
	       __detail::__make_unsigned_like_t<iter_difference_t<_It>> __n)
	requires (_Kind == subrange_kind::sized)
      : _M_begin(std::move(__i)), _M_end(__s)
      {
	using __detail::__to_unsigned_like;
	__glibcxx_assert(__n == __to_unsigned_like(ranges::distance(__i, __s)));
	if constexpr (_S_store_size)
	  _M_size._M_size = __n;
      }

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

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

template<borrowed_range _Rng>
	requires __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
	  && convertible_to<sentinel_t<_Rng>, _Sent>
	constexpr
	subrange(_Rng&& __r,
		 __detail::__make_unsigned_like_t<iter_difference_t<_It>> __n)
	requires (_Kind == subrange_kind::sized)
	: subrange{ranges::begin(__r), ranges::end(__r), __n}
	{ }

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

constexpr _It
      begin() const requires copyable<_It>
      { return _M_begin; }

[[nodiscard]] constexpr _It
      begin() requires (!copyable<_It>)
      { return std::move(_M_begin); }

constexpr _Sent end() const { return _M_end; }

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

constexpr __detail::__make_unsigned_like_t<iter_difference_t<_It>>
      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<_It> __n = 1) const &
	requires forward_iterator<_It>
      {
	auto __tmp = *this;
	__tmp.advance(__n);
	return __tmp;
      }

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

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

constexpr subrange&
      advance(iter_difference_t<_It> __n)
      {
	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	// 3433. subrange::advance(n) has UB when n < 0
	if constexpr (bidirectional_iterator<_It>)
	  if (__n < 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 >= 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<input_or_output_iterator _It, sentinel_for<_It> _Sent>
    subrange(_It, _Sent) -> subrange<_It, _Sent>;

template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
    subrange(_It, _Sent,
	     __detail::__make_unsigned_like_t<iter_difference_t<_It>>)
      -> subrange<_It, _Sent, subrange_kind::sized>;

template<__detail::__iterator_sentinel_pair _Pr>
    subrange(_Pr)
      -> subrange<tuple_element_t<0, _Pr>, tuple_element_t<1, _Pr>>;

template<__detail::__iterator_sentinel_pair _Pr>
    subrange(_Pr, __detail::__make_unsigned_like_t<iter_difference_t<
						     tuple_element_t<0, _Pr>>>)
      -> subrange<tuple_element_t<0, _Pr>, tuple_element_t<1, _Pr>,
		  subrange_kind::sized>;

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

template<borrowed_range _Rng>
    subrange(_Rng&&,
	     __detail::__make_unsigned_like_t<range_difference_t<_Rng>>)
      -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>, subrange_kind::sized>;

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

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

template<input_or_output_iterator _It, sentinel_for<_It> _Sent,
	   subrange_kind _Kind>
    inline constexpr bool
      enable_borrowed_range<subrange<_It, _Sent, _Kind>> = true;

} // namespace ranges

using ranges::get;

namespace ranges
{
  /// Type returned by algorithms instead of a dangling iterator or subrange.
  struct dangling
  {
    constexpr dangling() noexcept = default;
    template<typename... _Args>
      constexpr dangling(_Args&&...) noexcept { }
  };

template<range _Range>
    using borrowed_iterator_t = conditional_t<borrowed_range<_Range>,
					      iterator_t<_Range>,
					      dangling>;

template<range _Range>
    using borrowed_subrange_t = conditional_t<borrowed_range<_Range>,
					      subrange<iterator_t<_Range>>,
					      dangling>;

template<typename _Tp> requires is_object_v<_Tp>
    class empty_view
    : public view_interface<empty_view<_Tp>>
    {
    public:
      static constexpr _Tp* begin() noexcept { return nullptr; }
      static constexpr _Tp* end() noexcept { return nullptr; }
      static constexpr _Tp* data() noexcept { return nullptr; }
      static constexpr size_t size() noexcept { return 0; }
      static constexpr bool empty() noexcept { return true; }
    };

template<typename _Tp>
    inline constexpr bool enable_borrowed_range<empty_view<_Tp>> = true;

namespace __detail
  {
    template<copy_constructible _Tp> requires is_object_v<_Tp>
      struct __box : std::optional<_Tp>
      {
	using std::optional<_Tp>::optional;

constexpr
	__box()
	noexcept(is_nothrow_default_constructible_v<_Tp>)
	requires default_initializable<_Tp>
	: std::optional<_Tp>{std::in_place}
	{ }

__box(const __box&) = default;
	__box(__box&&) = default;

using std::optional<_Tp>::operator=;

__box&
	operator=(const __box& __that)
	noexcept(is_nothrow_copy_constructible_v<_Tp>)
	requires (!assignable_from<_Tp&, const _Tp&>)
	{
	  if ((bool)__that)
	    this->emplace(*__that);
	  else
	    this->reset();
	  return *this;
	}

__box&
	operator=(__box&& __that)
	noexcept(is_nothrow_move_constructible_v<_Tp>)
	requires (!assignable_from<_Tp&, _Tp>)
	{
	  if ((bool)__that)
	    this->emplace(std::move(*__that));
	  else
	    this->reset();
	  return *this;
	}
      };

} // namespace __detail

/// A view that contains exactly one element.
  template<copy_constructible _Tp> requires is_object_v<_Tp>
    class single_view : public view_interface<single_view<_Tp>>
    {
    public:
      single_view() = default;

constexpr explicit
      single_view(const _Tp& __t)
      : _M_value(__t)
      { }

constexpr explicit
      single_view(_Tp&& __t)
      : _M_value(std::move(__t))
      { }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 3428. single_view's in place constructor should be explicit
      template<typename... _Args>
	requires constructible_from<_Tp, _Args...>
	constexpr explicit
	single_view(in_place_t, _Args&&... __args)
	: _M_value{in_place, std::forward<_Args>(__args)...}
	{ }

constexpr _Tp*
      begin() noexcept
      { return data(); }

constexpr const _Tp*
      begin() const noexcept
      { return data(); }

constexpr _Tp*
      end() noexcept
      { return data() + 1; }

constexpr const _Tp*
      end() const noexcept
      { return data() + 1; }

static constexpr size_t
      size() noexcept
      { return 1; }

constexpr _Tp*
      data() noexcept
      { return _M_value.operator->(); }

constexpr const _Tp*
      data() const noexcept
      { return _M_value.operator->(); }

private:
      __detail::__box<_Tp> _M_value;
    };

namespace __detail
  {
    template<typename _Wp>
      constexpr auto __to_signed_like(_Wp __w) noexcept
      {
	if constexpr (!integral<_Wp>)
	  return iter_difference_t<_Wp>();
	else if constexpr (sizeof(iter_difference_t<_Wp>) > sizeof(_Wp))
	  return iter_difference_t<_Wp>(__w);
	else if constexpr (sizeof(ptrdiff_t) > sizeof(_Wp))
	  return ptrdiff_t(__w);
	else if constexpr (sizeof(long long) > sizeof(_Wp))
	  return (long long)(__w);
#ifdef __SIZEOF_INT128__
	else if constexpr (__SIZEOF_INT128__ > sizeof(_Wp))
	  return __int128(__w);
#endif
	else
	  return __max_diff_type(__w);
      }

template<typename _Wp>
      using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));

template<typename _It>
      concept __decrementable = incrementable<_It>
	&& requires(_It __i)
	{
	    { --__i } -> same_as<_It&>;
	    { __i-- } -> same_as<_It>;
	};

template<typename _It>
      concept __advanceable = __decrementable<_It> && totally_ordered<_It>
	&& requires( _It __i, const _It __j, const __iota_diff_t<_It> __n)
	{
	  { __i += __n } -> same_as<_It&>;
	  { __i -= __n } -> same_as<_It&>;
	  _It(__j + __n);
	  _It(__n + __j);
	  _It(__j - __n);
	  { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
	};

} // namespace __detail

template<weakly_incrementable _Winc,
	   semiregular _Bound = unreachable_sentinel_t>
    requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
      && semiregular<_Winc>
    class iota_view : public view_interface<iota_view<_Winc, _Bound>>
    {
    private:
      struct _Sentinel;

struct _Iterator
      {
      private:
	static auto
	_S_iter_cat()
	{
	  using namespace __detail;
	  if constexpr (__advanceable<_Winc>)
	    return random_access_iterator_tag{};
	  else if constexpr (__decrementable<_Winc>)
	    return bidirectional_iterator_tag{};
	  else if constexpr (incrementable<_Winc>)
	    return forward_iterator_tag{};
	  else
	    return input_iterator_tag{};
	}

public:
	using iterator_category = decltype(_S_iter_cat());
	using value_type = _Winc;
	using difference_type = __detail::__iota_diff_t<_Winc>;

_Iterator() = default;

constexpr explicit
	_Iterator(_Winc __value)
	: _M_value(__value) { }

constexpr _Winc
	operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
	{ return _M_value; }

constexpr _Iterator&
	operator++()
	{
	  ++_M_value;
	  return *this;
	}

constexpr void
	operator++(int)
	{ ++*this; }

constexpr _Iterator
	operator++(int) requires incrementable<_Winc>
	{
	  auto __tmp = *this;
	  ++*this;
	  return __tmp;
	}

constexpr _Iterator&
	operator--() requires __detail::__decrementable<_Winc>
	{
	  --_M_value;
	  return *this;
	}

constexpr _Iterator
	operator--(int) requires __detail::__decrementable<_Winc>
	{
	  auto __tmp = *this;
	  --*this;
	  return __tmp;
	}

constexpr _Iterator&
	operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
	{
	  using __detail::__is_integer_like;
	  using __detail::__is_signed_integer_like;
	  if constexpr (__is_integer_like<_Winc>
	      && !__is_signed_integer_like<_Winc>)
	    {
	      if (__n >= difference_type(0))
		_M_value += static_cast<_Winc>(__n);
	      else
		_M_value -= static_cast<_Winc>(-__n);
	    }
	  else
	    _M_value += __n;
	  return *this;
	}

constexpr _Iterator&
	operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
	{
	  using __detail::__is_integer_like;
	  using __detail::__is_signed_integer_like;
	  if constexpr (__is_integer_like<_Winc>
	      && !__is_signed_integer_like<_Winc>)
	    {
	      if (__n >= difference_type(0))
		_M_value -= static_cast<_Winc>(__n);
	      else
		_M_value += static_cast<_Winc>(-__n);
	    }
	  else
	    _M_value -= __n;
	  return *this;
	}

constexpr _Winc
	operator[](difference_type __n) const
	requires __detail::__advanceable<_Winc>
	{ return _Winc(_M_value + __n); }

friend constexpr bool
	operator==(const _Iterator& __x, const _Iterator& __y)
	requires equality_comparable<_Winc>
	{ return __x._M_value == __y._M_value; }

friend constexpr bool
	operator<(const _Iterator& __x, const _Iterator& __y)
	requires totally_ordered<_Winc>
	{ return __x._M_value < __y._M_value; }

friend constexpr bool
	operator>(const _Iterator& __x, const _Iterator& __y)
	  requires totally_ordered<_Winc>
	{ return __y < __x; }

friend constexpr bool
	operator<=(const _Iterator& __x, const _Iterator& __y)
	  requires totally_ordered<_Winc>
	{ return !(__y < __x); }

friend constexpr bool
	operator>=(const _Iterator& __x, const _Iterator& __y)
	  requires totally_ordered<_Winc>
	{ return !(__x < __y); }

#ifdef __cpp_lib_three_way_comparison
	friend constexpr auto
	operator<=>(const _Iterator& __x, const _Iterator& __y)
	  requires totally_ordered<_Winc> && three_way_comparable<_Winc>
	{ return __x._M_value <=> __y._M_value; }
#endif

friend constexpr _Iterator
	operator+(_Iterator __i, difference_type __n)
	  requires __detail::__advanceable<_Winc>
	{ return __i += __n; }

friend constexpr _Iterator
	operator+(difference_type __n, _Iterator __i)
	  requires __detail::__advanceable<_Winc>
	{ return __i += __n; }

friend constexpr _Iterator
	operator-(_Iterator __i, difference_type __n)
	  requires __detail::__advanceable<_Winc>
	{ return __i -= __n; }

friend constexpr difference_type
	operator-(const _Iterator& __x, const _Iterator& __y)
	  requires __detail::__advanceable<_Winc>
	{
	  using __detail::__is_integer_like;
	  using __detail::__is_signed_integer_like;
	  using _Dt = difference_type;
	  if constexpr (__is_integer_like<_Winc>)
	    {
	      if constexpr (__is_signed_integer_like<_Winc>)
		return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
	      else
		return (__y._M_value > __x._M_value)
		  ? _Dt(-_Dt(__y._M_value - __x._M_value))
		  : _Dt(__x._M_value - __y._M_value);
	    }
	  else
	    return __x._M_value - __y._M_value;
	}

private:
	_Winc _M_value = _Winc();

friend _Sentinel;
      };

struct _Sentinel
      {
      private:
	constexpr bool
	_M_equal(const _Iterator& __x) const
	{ return __x._M_value == _M_bound; }

_Bound _M_bound = _Bound();

public:
	_Sentinel() = default;

constexpr explicit
	_Sentinel(_Bound __bound)
	: _M_bound(__bound) { }

friend constexpr bool
	operator==(const _Iterator& __x, const _Sentinel& __y)
	{ return __y._M_equal(__x); }

friend constexpr iter_difference_t<_Winc>
	operator-(const _Iterator& __x, const _Sentinel& __y)
	  requires sized_sentinel_for<_Bound, _Winc>
	{ return __x._M_value - __y._M_bound; }

friend constexpr iter_difference_t<_Winc>
	operator-(const _Sentinel& __x, const _Iterator& __y)
	  requires sized_sentinel_for<_Bound, _Winc>
	{ return -(__y - __x); }
      };

_Winc _M_value = _Winc();
      _Bound _M_bound = _Bound();

public:
      iota_view() = default;

constexpr explicit
      iota_view(_Winc __value)
      : _M_value(__value)
      { }

constexpr
      iota_view(type_identity_t<_Winc> __value,
		type_identity_t<_Bound> __bound)
      : _M_value(__value), _M_bound(__bound)
      {
	if constexpr (totally_ordered_with<_Winc, _Bound>)
	  {
	    __glibcxx_assert( bool(__value <= __bound) );
	  }
      }

constexpr _Iterator
      begin() const { return _Iterator{_M_value}; }

constexpr auto
      end() const
      {
	if constexpr (same_as<_Bound, unreachable_sentinel_t>)
	  return unreachable_sentinel;
	else
	  return _Sentinel{_M_bound};
      }

constexpr _Iterator
      end() const requires same_as<_Winc, _Bound>
      { return _Iterator{_M_bound}; }

constexpr auto
      size() const
      requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
      || (integral<_Winc> && integral<_Bound>)
      || sized_sentinel_for<_Bound, _Winc>
      {
	using __detail::__is_integer_like;
	using __detail::__to_unsigned_like;
	if constexpr (__is_integer_like<_Winc> && __is_integer_like<_Bound>)
	  return (_M_value < 0)
	    ? ((_M_bound < 0)
		? __to_unsigned_like(-_M_value) - __to_unsigned_like(-_M_bound)
		: __to_unsigned_like(_M_bound) + __to_unsigned_like(-_M_value))
	    : __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
	else
	  return __to_unsigned_like(_M_bound - _M_value);
      }
    };

template<typename _Winc, typename _Bound>
    requires (!__detail::__is_integer_like<_Winc>
	|| !__detail::__is_integer_like<_Bound>
	|| (__detail::__is_signed_integer_like<_Winc>
	    == __detail::__is_signed_integer_like<_Bound>))
    iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;

template<weakly_incrementable _Winc, semiregular _Bound>
    inline constexpr bool
      enable_borrowed_range<iota_view<_Winc, _Bound>> = true;

namespace views
{
  template<typename _Tp>
    inline constexpr empty_view<_Tp> empty{};

struct _Single
  {
    template<typename _Tp>
      constexpr auto
      operator()(_Tp&& __e) const
      { return single_view{std::forward<_Tp>(__e)}; }
  };

inline constexpr _Single single{};

struct _Iota
  {
    template<typename _Tp>
      constexpr auto
      operator()(_Tp&& __e) const
      { return iota_view{std::forward<_Tp>(__e)}; }

template<typename _Tp, typename _Up>
      constexpr auto
      operator()(_Tp&& __e, _Up&& __f) const
      { return iota_view{std::forward<_Tp>(__e), std::forward<_Up>(__f)}; }
  };

inline constexpr _Iota iota{};
} // namespace views

namespace __detail
  {
    template<typename _Val, typename _CharT, typename _Traits>
      concept __stream_extractable
	= requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
  } // namespace __detail

template<movable _Val, typename _CharT, typename _Traits>
    requires default_initializable<_Val>
      && __detail::__stream_extractable<_Val, _CharT, _Traits>
    class basic_istream_view
    : public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
    {
    public:
      basic_istream_view() = default;

constexpr explicit
      basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
	: _M_stream(std::__addressof(__stream))
      { }

constexpr auto
      begin()
      {
	if (_M_stream != nullptr)
	  *_M_stream >> _M_object;
	return _Iterator{*this};
      }

constexpr default_sentinel_t
      end() const noexcept
      { return default_sentinel; }

private:
      basic_istream<_CharT, _Traits>* _M_stream = nullptr;
      _Val _M_object = _Val();

struct _Iterator
      {
      public:
	using iterator_concept = input_iterator_tag;
	using difference_type = ptrdiff_t;
	using value_type = _Val;

_Iterator() = default;

constexpr explicit
	_Iterator(basic_istream_view& __parent) noexcept
	  : _M_parent(std::__addressof(__parent))
	{ }

_Iterator(const _Iterator&) = delete;
	_Iterator(_Iterator&&) = default;
	_Iterator& operator=(const _Iterator&) = delete;
	_Iterator& operator=(_Iterator&&) = default;

_Iterator&
	operator++()
	{
	  __glibcxx_assert(_M_parent->_M_stream != nullptr);
	  *_M_parent->_M_stream >> _M_parent->_M_object;
	  return *this;
	}

void
	operator++(int)
	{ ++*this; }

_Val&
	operator*() const
	{
	  __glibcxx_assert(_M_parent->_M_stream != nullptr);
	  return _M_parent->_M_object;
	}

friend bool
	operator==(const _Iterator& __x, default_sentinel_t)
	{ return __x._M_at_end(); }

private:
	basic_istream_view* _M_parent = nullptr;

bool
	_M_at_end() const
	{ return _M_parent == nullptr || !*_M_parent->_M_stream; }
      };

friend _Iterator;
    };

template<typename _Val, typename _CharT, typename _Traits>
    basic_istream_view<_Val, _CharT, _Traits>
    istream_view(basic_istream<_CharT, _Traits>& __s)
    { return basic_istream_view<_Val, _CharT, _Traits>{__s}; }

namespace __detail
{
  struct _Empty { };

// Alias for a type that is conditionally present
  // (and is an empty type otherwise).
  // Data members using this alias should use [[no_unique_address]] so that
  // they take no space when not needed.
  template<bool _Present, typename _Tp>
    using __maybe_present_t = conditional_t<_Present, _Tp, _Empty>;

// Alias for a type that is conditionally const.
  template<bool _Const, typename _Tp>
    using __maybe_const_t = conditional_t<_Const, const _Tp, _Tp>;

} // namespace __detail

namespace views
{
  namespace __adaptor
  {
    template<typename _Tp>
      inline constexpr auto
      __maybe_refwrap(_Tp& __arg)
      { return reference_wrapper<_Tp>{__arg}; }

template<typename _Tp>
      inline constexpr auto
      __maybe_refwrap(const _Tp& __arg)
      { return reference_wrapper<const _Tp>{__arg}; }

template<typename _Tp>
      inline constexpr decltype(auto)
      __maybe_refwrap(_Tp&& __arg)
      { return std::forward<_Tp>(__arg); }

template<typename _Callable>
      struct _RangeAdaptorClosure;

template<typename _Callable>
      struct _RangeAdaptor
      {
      protected:
	[[no_unique_address]]
	  __detail::__maybe_present_t<!is_default_constructible_v<_Callable>,
				      _Callable> _M_callable;

public:
	constexpr
	_RangeAdaptor(const _Callable& = {})
	  requires is_default_constructible_v<_Callable>
	{ }

constexpr
	_RangeAdaptor(_Callable __callable)
	  requires (!is_default_constructible_v<_Callable>)
	  : _M_callable(std::move(__callable))
	{ }

template<typename... _Args>
	  requires (sizeof...(_Args) >= 1)
	  constexpr auto
	  operator()(_Args&&... __args) const
	  {
	    // [range.adaptor.object]: If a range adaptor object accepts more
	    // than one argument, then the following expressions are equivalent:
	    //
	    //   (1) adaptor(range, args...)
	    //   (2) adaptor(args...)(range)
	    //   (3) range | adaptor(args...)
	    //
	    // In this case, adaptor(args...) is a range adaptor closure object.
	    //
	    // We handle (1) and (2) here, and (3) is just a special case of a
	    // more general case already handled by _RangeAdaptorClosure.
	    if constexpr (is_invocable_v<_Callable, _Args...>)
	      {
		static_assert(sizeof...(_Args) != 1,
			      "a _RangeAdaptor that accepts only one argument "
			      "should be defined as a _RangeAdaptorClosure");
		// Here we handle adaptor(range, args...) -- just forward all
		// arguments to the underlying adaptor routine.
		return _Callable{}(std::forward<_Args>(__args)...);
	      }
	    else
	      {
		// Here we handle adaptor(args...)(range).
		// Given args..., we return a _RangeAdaptorClosure that takes a
		// range argument, such that (2) is equivalent to (1).
		//
		// We need to be careful about how we capture args... in this
		// closure.  By using __maybe_refwrap, we capture lvalue
		// references by reference (through a reference_wrapper) and
		// otherwise capture by value.
		auto __closure
		  = [...__args(__maybe_refwrap(std::forward<_Args>(__args)))]
		    <typename _Range> (_Range&& __r) {
		      // This static_cast has two purposes: it forwards a
		      // reference_wrapper<T> capture as a T&, and otherwise
		      // forwards the captured argument as an rvalue.
		      return _Callable{}(std::forward<_Range>(__r),
			       (static_cast<unwrap_reference_t
					    <remove_const_t<decltype(__args)>>>
				(__args))...);
		    };
		using _ClosureType = decltype(__closure);
		return _RangeAdaptorClosure<_ClosureType>(std::move(__closure));
	      }
	  }
      };

template<typename _Callable>
      _RangeAdaptor(_Callable) -> _RangeAdaptor<_Callable>;

template<typename _Callable>
      struct _RangeAdaptorClosure : public _RangeAdaptor<_Callable>
      {
	using _RangeAdaptor<_Callable>::_RangeAdaptor;

template<viewable_range _Range>
	  requires requires { declval<_Callable>()(declval<_Range>()); }
	  constexpr auto
	  operator()(_Range&& __r) const
	  {
	    if constexpr (is_default_constructible_v<_Callable>)
	      return _Callable{}(std::forward<_Range>(__r));
	    else
	      return this->_M_callable(std::forward<_Range>(__r));
	  }

template<viewable_range _Range>
	  requires requires { declval<_Callable>()(declval<_Range>()); }
	  friend constexpr auto
	  operator|(_Range&& __r, const _RangeAdaptorClosure& __o)
	  { return __o(std::forward<_Range>(__r)); }

template<typename _Tp>
	  friend constexpr auto
	  operator|(const _RangeAdaptorClosure<_Tp>& __x,
		    const _RangeAdaptorClosure& __y)
	  {
	    if constexpr (is_default_constructible_v<_Tp>
			  && is_default_constructible_v<_Callable>)
	      {
		auto __closure = [] <typename _Up> (_Up&& __e) {
		  return std::forward<_Up>(__e) | decltype(__x){} | decltype(__y){};
		};
		return _RangeAdaptorClosure<decltype(__closure)>(__closure);
	      }
	    else if constexpr (is_default_constructible_v<_Tp>
			       && !is_default_constructible_v<_Callable>)
	      {
		auto __closure = [__y] <typename _Up> (_Up&& __e) {
		  return std::forward<_Up>(__e) | decltype(__x){} | __y;
		};
		return _RangeAdaptorClosure<decltype(__closure)>(__closure);
	      }
	    else if constexpr (!is_default_constructible_v<_Tp>
			       && is_default_constructible_v<_Callable>)
	      {
		auto __closure = [__x] <typename _Up> (_Up&& __e) {
		  return std::forward<_Up>(__e) | __x | decltype(__y){};
		};
		return _RangeAdaptorClosure<decltype(__closure)>(__closure);
	      }
	    else
	      {
		auto __closure = [__x, __y] <typename _Up> (_Up&& __e) {
		  return std::forward<_Up>(__e) | __x | __y;
		};
		return _RangeAdaptorClosure<decltype(__closure)>(__closure);
	      }
	  }
      };

template<typename _Callable>
      _RangeAdaptorClosure(_Callable) -> _RangeAdaptorClosure<_Callable>;
  } // namespace __adaptor
} // namespace views

template<range _Range> requires is_object_v<_Range>
    class ref_view : public view_interface<ref_view<_Range>>
    {
    private:
      _Range* _M_r = nullptr;

static void _S_fun(_Range&); // not defined
      static void _S_fun(_Range&&) = delete;

public:
      constexpr
      ref_view() noexcept = default;

template<__detail::__not_same_as<ref_view> _Tp>
	requires convertible_to<_Tp, _Range&>
	  && requires { _S_fun(declval<_Tp>()); }
	constexpr
	ref_view(_Tp&& __t)
	  : _M_r(std::__addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))
	{ }

constexpr _Range&
      base() const
      { return *_M_r; }

constexpr iterator_t<_Range>
      begin() const
      { return ranges::begin(*_M_r); }

constexpr sentinel_t<_Range>
      end() const
      { return ranges::end(*_M_r); }

constexpr bool
      empty() const requires requires { ranges::empty(*_M_r); }
      { return ranges::empty(*_M_r); }

constexpr auto
      size() const requires sized_range<_Range>
      { return ranges::size(*_M_r); }

constexpr auto
      data() const requires contiguous_range<_Range>
      { return ranges::data(*_M_r); }
    };

template<typename _Range>
    ref_view(_Range&) -> ref_view<_Range>;

template<typename _Tp>
    inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;

namespace views
  {
    inline constexpr __adaptor::_RangeAdaptorClosure all
      = [] <viewable_range _Range> (_Range&& __r)
      {
	if constexpr (view<decay_t<_Range>>)
	  return std::forward<_Range>(__r);
	else if constexpr (requires { ref_view{std::forward<_Range>(__r)}; })
	  return ref_view{std::forward<_Range>(__r)};
	else
	  return subrange{std::forward<_Range>(__r)};
      };

template<viewable_range _Range>
      using all_t = decltype(all(std::declval<_Range>()));

} // namespace views

// XXX: the following algos are copied from ranges_algo.h to avoid a circular
  // dependency with that header.
  namespace __detail
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
	     typename _Proj = identity,
	     indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr _Iter
      find_if(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {})
      {
	while (__first != __last
	    && !(bool)std::__invoke(__pred, std::__invoke(__proj, *__first)))
	  ++__first;
	return __first;
      }

template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
	     typename _Proj = identity,
	     indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr _Iter
      find_if_not(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {})
      {
	while (__first != __last
	    && (bool)std::__invoke(__pred, std::__invoke(__proj, *__first)))
	  ++__first;
	return __first;
      }

template<typename _Tp, typename _Proj = identity,
	     indirect_strict_weak_order<projected<const _Tp*, _Proj>>
	       _Comp = ranges::less>
      constexpr const _Tp&
      min(const _Tp& __a, const _Tp& __b, _Comp __comp = {}, _Proj __proj = {})
      {
	if (std::__invoke(std::move(__comp),
			  std::__invoke(__proj, __b),
			  std::__invoke(__proj, __a)))
	  return __b;
	else
	  return __a;
      }

template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
	     input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
	     typename _Pred = ranges::equal_to,
	     typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
      constexpr pair<_Iter1, _Iter2>
      mismatch(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
	       _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {})
      {
	while (__first1 != __last1 && __first2 != __last2
	       && (bool)std::__invoke(__pred,
				      std::__invoke(__proj1, *__first1),
				      std::__invoke(__proj2, *__first2)))
	{
	  ++__first1;
	  ++__first2;
	}
	return { std::move(__first1), std::move(__first2) };
      }
  } // namespace __detail

namespace __detail
  {
    template<range _Range>
      struct _CachedPosition
      {
	constexpr bool
	_M_has_value() const
	{ return false; }

constexpr iterator_t<_Range>
	_M_get(const _Range&) const
	{
	  __glibcxx_assert(false);
	  return {};
	}

constexpr void
	_M_set(const _Range&, const iterator_t<_Range>&) const
	{ }
      };

template<forward_range _Range>
      struct _CachedPosition<_Range>
      {
      private:
	iterator_t<_Range> _M_iter{};

public:
	constexpr bool
	_M_has_value() const
	{ return _M_iter != iterator_t<_Range>{}; }

constexpr iterator_t<_Range>
	_M_get(const _Range&) const
	{
	  __glibcxx_assert(_M_has_value());
	  return _M_iter;
	}

constexpr void
	_M_set(const _Range&, const iterator_t<_Range>& __it)
	{
	  __glibcxx_assert(!_M_has_value());
	  _M_iter = __it;
	}
      };

template<random_access_range _Range>
      requires (sizeof(range_difference_t<_Range>)
		<= sizeof(iterator_t<_Range>))
      struct _CachedPosition<_Range>
      {
      private:
	range_difference_t<_Range> _M_offset = -1;

public:
	constexpr bool
	_M_has_value() const
	{ return _M_offset >= 0; }

constexpr iterator_t<_Range>
	_M_get(_Range& __r) const
	{
	  __glibcxx_assert(_M_has_value());
	  return ranges::begin(__r) + _M_offset;
	}

constexpr void
	_M_set(_Range& __r, const iterator_t<_Range>& __it)
	{
	  __glibcxx_assert(!_M_has_value());
	  _M_offset = __it - ranges::begin(__r);
	}
      };

} // namespace __detail

template<input_range _Vp,
	   indirect_unary_predicate<iterator_t<_Vp>> _Pred>
    requires view<_Vp> && is_object_v<_Pred>
    class filter_view : public view_interface<filter_view<_Vp, _Pred>>
    {
    private:
      struct _Sentinel;

struct _Iterator
      {
      private:
	static constexpr auto
	_S_iter_concept()
	{
	  if constexpr (bidirectional_range<_Vp>)
	    return bidirectional_iterator_tag{};
	  else if constexpr (forward_range<_Vp>)
	    return forward_iterator_tag{};
	  else
	    return input_iterator_tag{};
	}

static constexpr auto
	_S_iter_cat()
	{
	  using _Cat = typename iterator_traits<_Vp_iter>::iterator_category;
	  if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
	    return bidirectional_iterator_tag{};
	  else if constexpr (derived_from<_Cat, forward_iterator_tag>)
	    return forward_iterator_tag{};
	  else
	    return _Cat{};
	}

friend filter_view;

using _Vp_iter = iterator_t<_Vp>;

_Vp_iter _M_current = _Vp_iter();
	filter_view* _M_parent = nullptr;

public:
	using iterator_concept = decltype(_S_iter_concept());
	using iterator_category = decltype(_S_iter_cat());
	using value_type = range_value_t<_Vp>;
	using difference_type = range_difference_t<_Vp>;

_Iterator() = default;

constexpr
	_Iterator(filter_view& __parent, _Vp_iter __current)
	  : _M_current(std::move(__current)),
	    _M_parent(std::__addressof(__parent))
	{ }

constexpr _Vp_iter
	base() const &
	  requires copyable<_Vp_iter>
	{ return _M_current; }

constexpr _Vp_iter
	base() &&
	{ return std::move(_M_current); }

constexpr range_reference_t<_Vp>
	operator*() const
	{ return *_M_current; }

constexpr _Vp_iter
	operator->() const
	  requires __detail::__has_arrow<_Vp_iter>
	    && copyable<_Vp_iter>
	{ return _M_current; }

constexpr _Iterator&
	operator++()
	{
	  _M_current = __detail::find_if(std::move(++_M_current),
					 ranges::end(_M_parent->_M_base),
					 std::ref(*_M_parent->_M_pred));
	  return *this;
	}

constexpr void
	operator++(int)
	{ ++*this; }

constexpr _Iterator
	operator++(int) requires forward_range<_Vp>
	{
	  auto __tmp = *this;
	  ++*this;
	  return __tmp;
	}

constexpr _Iterator&
	operator--() requires bidirectional_range<_Vp>
	{
	  do
	    --_M_current;
	  while (!std::__invoke(*_M_parent->_M_pred, *_M_current));
	  return *this;
	}

constexpr _Iterator
	operator--(int) requires bidirectional_range<_Vp>
	{
	  auto __tmp = *this;
	  --*this;
	  return __tmp;
	}

friend constexpr bool
	operator==(const _Iterator& __x, const _Iterator& __y)
	  requires equality_comparable<_Vp_iter>
	{ return __x._M_current == __y._M_current; }

friend constexpr range_rvalue_reference_t<_Vp>
	iter_move(const _Iterator& __i)
	  noexcept(noexcept(ranges::iter_move(__i._M_current)))
	{ return ranges::iter_move(__i._M_current); }

friend constexpr void
	iter_swap(const _Iterator& __x, const _Iterator& __y)
	  noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
	  requires indirectly_swappable<_Vp_iter>
	{ ranges::iter_swap(__x._M_current, __y._M_current); }
      };

struct _Sentinel
      {
      private:
	sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();

constexpr bool
	__equal(const _Iterator& __i) const
	{ return __i._M_current == _M_end; }

public:
	_Sentinel() = default;

constexpr explicit
	_Sentinel(filter_view& __parent)
	  : _M_end(ranges::end(__parent._M_base))
	{ }

constexpr sentinel_t<_Vp>
	base() const
	{ return _M_end; }

friend constexpr bool
	operator==(const _Iterator& __x, const _Sentinel& __y)
	{ return __y.__equal(__x); }
      };

_Vp _M_base = _Vp();
      __detail::__box<_Pred> _M_pred;
      [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;

public:
      filter_view() = default;

constexpr
      filter_view(_Vp __base, _Pred __pred)
	: _M_base(std::move(__base)), _M_pred(std::move(__pred))
      { }

constexpr _Vp
      base() const& requires copy_constructible<_Vp>
      { return _M_base; }

constexpr _Vp
      base() &&
      { return std::move(_M_base); }

constexpr const _Pred&
      pred() const
      { return *_M_pred; }

constexpr _Iterator
      begin()
      {
	if (_M_cached_begin._M_has_value())
	  return {*this, _M_cached_begin._M_get(_M_base)};

__glibcxx_assert(_M_pred.has_value());
	auto __it = __detail::find_if(ranges::begin(_M_base),
				      ranges::end(_M_base),
				      std::ref(*_M_pred));
	_M_cached_begin._M_set(_M_base, __it);
	return {*this, std::move(__it)};
      }

constexpr auto
      end()
      {
	if constexpr (common_range<_Vp>)
	  return _Iterator{*this, ranges::end(_M_base)};
	else
	  return _Sentinel{*this};
      }
    };

template<typename _Range, typename _Pred>
    filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;

namespace views
  {
    inline constexpr __adaptor::_RangeAdaptor filter
      = [] <viewable_range _Range, typename _Pred> (_Range&& __r, _Pred&& __p)
      {
	return filter_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)};
      };
  } // namespace views

template<input_range _Vp, copy_constructible _Fp>
    requires view<_Vp> && is_object_v<_Fp>
      && regular_invocable<_Fp&, range_reference_t<_Vp>>
      && std::__detail::__can_reference<invoke_result_t<_Fp&,
							range_reference_t<_Vp>>>
    class transform_view : public view_interface<transform_view<_Vp, _Fp>>
    {
    private:
      template<bool _Const>
	struct _Sentinel;

template<bool _Const>
	struct _Iterator
	{
	private:
	  using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
	  using _Base = __detail::__maybe_const_t<_Const, _Vp>;

static constexpr auto
	  _S_iter_concept()
	  {
	    if constexpr (random_access_range<_Vp>)
	      return random_access_iterator_tag{};
	    else if constexpr (bidirectional_range<_Vp>)
	      return bidirectional_iterator_tag{};
	    else if constexpr (forward_range<_Vp>)
	      return forward_iterator_tag{};
	    else
	      return input_iterator_tag{};
	  }

static constexpr auto
	  _S_iter_cat()
	  {
	    using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>;
	    if constexpr (is_lvalue_reference_v<_Res>)
	      {
		using _Cat
		  = typename iterator_traits<_Base_iter>::iterator_category;
		if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
		  return random_access_iterator_tag{};
		else
		  return _Cat{};
	      }
	    else
	      return input_iterator_tag{};
	  }

using _Base_iter = iterator_t<_Base>;

_Base_iter _M_current = _Base_iter();
	  _Parent* _M_parent = nullptr;

public:
	  using iterator_concept = decltype(_S_iter_concept());
	  using iterator_category = decltype(_S_iter_cat());
	  using value_type
	    = remove_cvref_t<invoke_result_t<_Fp&, range_reference_t<_Base>>>;
	  using difference_type = range_difference_t<_Base>;

_Iterator() = default;

constexpr
	  _Iterator(_Parent& __parent, _Base_iter __current)
	    : _M_current(std::move(__current)),
	      _M_parent(std::__addressof(__parent))
	  { }

constexpr
	  _Iterator(_Iterator<!_Const> __i)
	    requires _Const
	      && convertible_to<iterator_t<_Vp>, _Base_iter>
	    : _M_current(std::move(__i._M_current)), _M_parent(__i._M_parent)
	  { }

constexpr _Base_iter
	  base() const &
	    requires copyable<_Base_iter>
	  { return _M_current; }

constexpr _Base_iter
	  base() &&
	  { return std::move(_M_current); }

constexpr decltype(auto)
	  operator*() const
	    noexcept(noexcept(std::__invoke(*_M_parent->_M_fun, *_M_current)))
	  { return std::__invoke(*_M_parent->_M_fun, *_M_current); }

constexpr _Iterator&
	  operator++()
	  {
	    ++_M_current;
	    return *this;
	  }

constexpr void
	  operator++(int)
	  { ++_M_current; }

constexpr _Iterator
	  operator++(int) requires forward_range<_Base>
	  {
	    auto __tmp = *this;
	    ++*this;
	    return __tmp;
	  }

constexpr _Iterator&
	  operator--() requires bidirectional_range<_Base>
	  {
	    --_M_current;
	    return *this;
	  }

constexpr _Iterator
	  operator--(int) requires bidirectional_range<_Base>
	  {
	    auto __tmp = *this;
	    --*this;
	    return __tmp;
	  }

constexpr _Iterator&
	  operator+=(difference_type __n) requires random_access_range<_Base>
	  {
	    _M_current += __n;
	    return *this;
	  }

constexpr _Iterator&
	  operator-=(difference_type __n) requires random_access_range<_Base>
	  {
	    _M_current -= __n;
	    return *this;
	  }

constexpr decltype(auto)
	  operator[](difference_type __n) const
	    requires random_access_range<_Base>
	  { return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }

friend constexpr bool
	  operator==(const _Iterator& __x, const _Iterator& __y)
	    requires equality_comparable<_Base_iter>
	  { return __x._M_current == __y._M_current; }

friend constexpr bool
	  operator<(const _Iterator& __x, const _Iterator& __y)
	    requires random_access_range<_Base>
	  { return __x._M_current < __y._M_current; }

friend constexpr bool
	  operator>(const _Iterator& __x, const _Iterator& __y)
	    requires random_access_range<_Base>
	  { return __y < __x; }

friend constexpr bool
	  operator<=(const _Iterator& __x, const _Iterator& __y)
	    requires random_access_range<_Base>
	  { return !(__y < __x); }

friend constexpr bool
	  operator>=(const _Iterator& __x, const _Iterator& __y)
	    requires random_access_range<_Base>
	  { return !(__x < __y); }

#ifdef __cpp_lib_three_way_comparison
	  friend constexpr auto
	  operator<=>(const _Iterator& __x, const _Iterator& __y)
	    requires random_access_range<_Base>
	      && three_way_comparable<_Base_iter>
	  { return __x._M_current <=> __y._M_current; }
#endif

friend constexpr _Iterator
	  operator+(_Iterator __i, difference_type __n)
	    requires random_access_range<_Base>
	  { return {*__i._M_parent, __i._M_current + __n}; }

friend constexpr _Iterator
	  operator+(difference_type __n, _Iterator __i)
	    requires random_access_range<_Base>
	  { return {*__i._M_parent, __i._M_current + __n}; }

friend constexpr _Iterator
	  operator-(_Iterator __i, difference_type __n)
	    requires random_access_range<_Base>
	  { return {*__i._M_parent, __i._M_current - __n}; }

friend constexpr difference_type
	  operator-(const _Iterator& __x, const _Iterator& __y)
	    requires random_access_range<_Base>
	  { return __x._M_current - __y._M_current; }

friend constexpr decltype(auto)
	  iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
	  {
	    if constexpr (is_lvalue_reference_v<decltype(*__i)>)
	      return std::move(*__i);
	    else
	      return *__i;
	  }

friend constexpr void
	  iter_swap(const _Iterator& __x, const _Iterator& __y)
	    noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
	    requires indirectly_swappable<_Base_iter>
	  { return ranges::iter_swap(__x._M_current, __y._M_current); }

friend _Iterator<!_Const>;
	  template<bool> friend struct _Sentinel;
	};

template<bool _Const>
	struct _Sentinel
	{
	private:
	  using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
	  using _Base = __detail::__maybe_const_t<_Const, _Vp>;

template<bool _Const2>
	    constexpr auto
	    __distance_from(const _Iterator<_Const2>& __i) const
	    { return _M_end - __i._M_current; }

template<bool _Const2>
	    constexpr bool
	    __equal(const _Iterator<_Const2>& __i) const
	    { return __i._M_current == _M_end; }

sentinel_t<_Base> _M_end = sentinel_t<_Base>();

public:
	  _Sentinel() = default;

constexpr explicit
	  _Sentinel(sentinel_t<_Base> __end)
	    : _M_end(__end)
	  { }

constexpr
	  _Sentinel(_Sentinel<!_Const> __i)
	    requires _Const
	      && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
	    : _M_end(std::move(__i._M_end))
	  { }

constexpr sentinel_t<_Base>
	  base() const
	  { return _M_end; }

template<bool _Const2>
	    requires sentinel_for<sentinel_t<_Base>,
		       iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
	    friend constexpr bool
	    operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
	    { return __y.__equal(__x); }

template<bool _Const2,
		   typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
	    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
	    friend constexpr range_difference_t<_Base2>
	    operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
	    { return -__y.__distance_from(__x); }

template<bool _Const2,
		   typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
	    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
	    friend constexpr range_difference_t<_Base2>
	    operator-(const _Sentinel& __y, const _Iterator<_Const2>& __x)
	    { return __y.__distance_from(__x); }

friend _Sentinel<!_Const>;
	};

_Vp _M_base = _Vp();
      __detail::__box<_Fp> _M_fun;

public:
      transform_view() = default;

constexpr
      transform_view(_Vp __base, _Fp __fun)
	: _M_base(std::move(__base)), _M_fun(std::move(__fun))
      { }

constexpr _Vp
      base() const& requires copy_constructible<_Vp>
      { return _M_base ; }

constexpr _Vp
      base() &&
      { return std::move(_M_base); }

constexpr _Iterator<false>
      begin()
      { return _Iterator<false>{*this, ranges::begin(_M_base)}; }

constexpr _Iterator<true>
      begin() const
	requires range<const _Vp>
	  && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
      { return _Iterator<true>{*this, ranges::begin(_M_base)}; }

constexpr _Sentinel<false>
      end()
      { return _Sentinel<false>{ranges::end(_M_base)}; }

constexpr _Iterator<false>
      end() requires common_range<_Vp>
      { return _Iterator<false>{*this, ranges::end(_M_base)}; }

constexpr _Sentinel<true>
      end() const
	requires range<const _Vp>
	  && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
      { return _Sentinel<true>{ranges::end(_M_base)}; }

constexpr _Iterator<true>
      end() const
	requires common_range<const _Vp>
	  && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
      { return _Iterator<true>{*this, ranges::end(_M_base)}; }

constexpr auto
      size() requires sized_range<_Vp>
      { return ranges::size(_M_base); }

constexpr auto
      size() const requires sized_range<const _Vp>
      { return ranges::size(_M_base); }
    };

template<typename _Range, typename _Fp>
    transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;

namespace views
  {
    inline constexpr __adaptor::_RangeAdaptor transform
      = [] <viewable_range _Range, typename _Fp> (_Range&& __r, _Fp&& __f)
      {
	return transform_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)};
      };
  } // namespace views

template<view _Vp>
    class take_view : public view_interface<take_view<_Vp>>
    {
    private:
      template<bool _Const>
	using _CI = counted_iterator<
	  iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;

template<bool _Const>
	struct _Sentinel
	{
	private:
	  using _Base = __detail::__maybe_const_t<_Const, _Vp>;
	  sentinel_t<_Base> _M_end = sentinel_t<_Base>();

public:
	  _Sentinel() = default;

constexpr explicit
	  _Sentinel(sentinel_t<_Base> __end)
	    : _M_end(__end)
	  { }

constexpr
	  _Sentinel(_Sentinel<!_Const> __s)
	    requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
	    : _M_end(std::move(__s._M_end))
	  { }

constexpr sentinel_t<_Base>
	  base() const
	  { return _M_end; }

friend constexpr bool
	  operator==(const _CI<_Const>& __y, const _Sentinel& __x)
	  { return __y.count() == 0 || __y.base() == __x._M_end; }

template<bool _OtherConst = !_Const,
		   typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
	    requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
	  friend constexpr bool
	  operator==(const _CI<_OtherConst>& __y, const _Sentinel& __x)
	  { return __y.count() == 0 || __y.base() == __x._M_end; }

friend _Sentinel<!_Const>;
	};

_Vp _M_base = _Vp();
      range_difference_t<_Vp> _M_count = 0;

public:
      take_view() = default;

constexpr
      take_view(_Vp base, range_difference_t<_Vp> __count)
	: _M_base(std::move(base)), _M_count(std::move(__count))
      { }

constexpr _Vp
      base() const& requires copy_constructible<_Vp>
      { return _M_base; }

constexpr _Vp
      base() &&
      { return std::move(_M_base); }

constexpr auto
      begin() requires (!__detail::__simple_view<_Vp>)
      {
	if constexpr (sized_range<_Vp>)
	  {
	    if constexpr (random_access_range<_Vp>)
	      return ranges::begin(_M_base);
	    else
	      {
		auto __sz = size();
		return counted_iterator{ranges::begin(_M_base), __sz};
	      }
	  }
	else
	  return counted_iterator{ranges::begin(_M_base), _M_count};
      }

constexpr auto
      begin() const requires range<const _Vp>
      {
	if constexpr (sized_range<const _Vp>)
	  {
	    if constexpr (random_access_range<const _Vp>)
	      return ranges::begin(_M_base);
	    else
	      {
		auto __sz = size();
		return counted_iterator{ranges::begin(_M_base), __sz};
	      }
	  }
	else
	  return counted_iterator{ranges::begin(_M_base), _M_count};
      }

constexpr auto
      end() requires (!__detail::__simple_view<_Vp>)
      {
	if constexpr (sized_range<_Vp>)
	  {
	    if constexpr (random_access_range<_Vp>)
	      return ranges::begin(_M_base) + size();
	    else
	      return default_sentinel;
	  }
	else
	  return _Sentinel<false>{ranges::end(_M_base)};
      }

constexpr auto
      end() const requires range<const _Vp>
      {
	if constexpr (sized_range<const _Vp>)
	  {
	    if constexpr (random_access_range<const _Vp>)
	      return ranges::begin(_M_base) + size();
	    else
	      return default_sentinel;
	  }
	else
	  return _Sentinel<true>{ranges::end(_M_base)};
      }

constexpr auto
      size() requires sized_range<_Vp>
      {
	auto __n = ranges::size(_M_base);
	return __detail::min(__n, static_cast<decltype(__n)>(_M_count));
      }

constexpr auto
      size() const requires sized_range<const _Vp>
      {
	auto __n = ranges::size(_M_base);
	return __detail::min(__n, static_cast<decltype(__n)>(_M_count));
      }
    };

// _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 3447. Deduction guides for take_view and drop_view have different
  // constraints
  template<typename _Range>
    take_view(_Range&&, range_difference_t<_Range>)
      -> take_view<views::all_t<_Range>>;

namespace views
  {
    inline constexpr __adaptor::_RangeAdaptor take
      = [] <viewable_range _Range, typename _Tp> (_Range&& __r, _Tp&& __n)
      {
	return take_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)};
      };
  } // namespace views

template<view _Vp, typename _Pred>
    requires input_range<_Vp> && is_object_v<_Pred>
      && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
    class take_while_view : public view_interface<take_while_view<_Vp, _Pred>>
    {
      template<bool _Const>
	struct _Sentinel
	{
	private:
	  using _Base = __detail::__maybe_const_t<_Const, _Vp>;

sentinel_t<_Base> _M_end = sentinel_t<_Base>();
	  const _Pred* _M_pred = nullptr;

public:
	  _Sentinel() = default;

constexpr explicit
	  _Sentinel(sentinel_t<_Base> __end, const _Pred* __pred)
	    : _M_end(__end), _M_pred(__pred)
	  { }

constexpr
	  _Sentinel(_Sentinel<!_Const> __s)
	    requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
	    : _M_end(__s._M_end), _M_pred(__s._M_pred)
	  { }

constexpr sentinel_t<_Base>
	  base() const { return _M_end; }

friend constexpr bool
	  operator==(const iterator_t<_Base>& __x, const _Sentinel& __y)
	  { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }

template<bool _OtherConst = !_Const,
		   typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
	    requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
	  friend constexpr bool
	  operator==(const iterator_t<_Base2>& __x, const _Sentinel& __y)
	  { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }

friend _Sentinel<!_Const>;
	};

_Vp _M_base = _Vp();
      __detail::__box<_Pred> _M_pred;

public:
      take_while_view() = default;

constexpr
      take_while_view(_Vp base, _Pred __pred)
	: _M_base(std::move(base)), _M_pred(std::move(__pred))
      {
      }

constexpr _Vp
      base() const& requires copy_constructible<_Vp>
      { return _M_base; }

constexpr _Vp
      base() &&
      { return std::move(_M_base); }

constexpr const _Pred&
      pred() const
      { return *_M_pred; }

constexpr auto
      begin() requires (!__detail::__simple_view<_Vp>)
      { return ranges::begin(_M_base); }

constexpr auto
      begin() const requires range<const _Vp>
	&& indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
      { return ranges::begin(_M_base); }

constexpr auto
      end() requires (!__detail::__simple_view<_Vp>)
      { return _Sentinel<false>(ranges::end(_M_base),
				std::__addressof(*_M_pred)); }

constexpr auto
      end() const requires range<const _Vp>
	&& indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
      { return _Sentinel<true>(ranges::end(_M_base),
			       std::__addressof(*_M_pred)); }
    };

template<typename _Range, typename _Pred>
    take_while_view(_Range&&, _Pred)
      -> take_while_view<views::all_t<_Range>, _Pred>;

namespace views
  {
    inline constexpr __adaptor::_RangeAdaptor take_while
      = [] <viewable_range _Range, typename _Pred> (_Range&& __r, _Pred&& __p)
      {
	return take_while_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)};
      };
  } // namespace views

template<view _Vp>
    class drop_view : public view_interface<drop_view<_Vp>>
    {
    private:
      _Vp _M_base = _Vp();
      range_difference_t<_Vp> _M_count = 0;

static constexpr bool _S_needs_cached_begin = !random_access_range<_Vp>;
      [[no_unique_address]]
	__detail::__maybe_present_t<_S_needs_cached_begin,
				    __detail::_CachedPosition<_Vp>>
				      _M_cached_begin;

public:
      drop_view() = default;

constexpr
      drop_view(_Vp __base, range_difference_t<_Vp> __count)
	: _M_base(std::move(__base)), _M_count(__count)
      { __glibcxx_assert(__count >= 0); }

constexpr _Vp
      base() const& requires copy_constructible<_Vp>
      { return _M_base; }

constexpr _Vp
      base() &&
      { return std::move(_M_base); }

constexpr auto
      begin() requires (!(__detail::__simple_view<_Vp>
			  && random_access_range<_Vp>))
      {
	if constexpr (_S_needs_cached_begin)
	  if (_M_cached_begin._M_has_value())
	    return _M_cached_begin._M_get(_M_base);

auto __it = ranges::next(ranges::begin(_M_base),
				 _M_count, ranges::end(_M_base));
	if constexpr (_S_needs_cached_begin)
	  _M_cached_begin._M_set(_M_base, __it);
	return __it;
      }

constexpr auto
      begin() const requires random_access_range<const _Vp>
      {
	return ranges::next(ranges::begin(_M_base), _M_count,
			    ranges::end(_M_base));
      }

constexpr auto
      end() requires (!__detail::__simple_view<_Vp>)
      { return ranges::end(_M_base); }

constexpr auto
      end() const requires range<const _Vp>
      { return ranges::end(_M_base); }

constexpr auto
      size() requires sized_range<_Vp>
      {
	const auto __s = ranges::size(_M_base);
	const auto __c = static_cast<decltype(__s)>(_M_count);
	return __s < __c ? 0 : __s - __c;
      }

constexpr auto
      size() const requires sized_range<const _Vp>
      {
	const auto __s = ranges::size(_M_base);
	const auto __c = static_cast<decltype(__s)>(_M_count);
	return __s < __c ? 0 : __s - __c;
      }
    };

template<typename _Range>
    drop_view(_Range&&, range_difference_t<_Range>)
      -> drop_view<views::all_t<_Range>>;

namespace views
  {
    inline constexpr __adaptor::_RangeAdaptor drop
      = [] <viewable_range _Range, typename _Tp> (_Range&& __r, _Tp&& __n)
      {
	return drop_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)};
      };
  } // namespace views

template<view _Vp, typename _Pred>
    requires input_range<_Vp> && is_object_v<_Pred>
      && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
    class drop_while_view : public view_interface<drop_while_view<_Vp, _Pred>>
    {
    private:
      _Vp _M_base = _Vp();
      __detail::__box<_Pred> _M_pred;
      [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;

public:
      drop_while_view() = default;

constexpr
      drop_while_view(_Vp __base, _Pred __pred)
	: _M_base(std::move(__base)), _M_pred(std::move(__pred))
      { }

constexpr _Vp
      base() const& requires copy_constructible<_Vp>
      { return _M_base; }

constexpr _Vp
      base() &&
      { return std::move(_M_base); }

constexpr const _Pred&
      pred() const
      { return *_M_pred; }

constexpr auto
      begin()
      {
	if (_M_cached_begin._M_has_value())
	  return _M_cached_begin._M_get(_M_base);

auto __it = __detail::find_if_not(ranges::begin(_M_base),
					  ranges::end(_M_base),
					  std::cref(*_M_pred));
	_M_cached_begin._M_set(_M_base, __it);
	return __it;
      }

constexpr auto
      end()
      { return ranges::end(_M_base); }
    };

template<typename _Range, typename _Pred>
    drop_while_view(_Range&&, _Pred)
      -> drop_while_view<views::all_t<_Range>, _Pred>;

namespace views
  {
    inline constexpr __adaptor::_RangeAdaptor drop_while
      = [] <viewable_range _Range, typename _Pred> (_Range&& __r, _Pred&& __p)
      {
	return drop_while_view{std::forward<_Range>(__r),
			       std::forward<_Pred>(__p)};
      };
  } // namespace views

template<input_range _Vp>
    requires view<_Vp> && input_range<range_reference_t<_Vp>>
      && (is_reference_v<range_reference_t<_Vp>>
	  || view<range_value_t<_Vp>>)
    class join_view : public view_interface<join_view<_Vp>>
    {
    private:
      using _InnerRange = range_reference_t<_Vp>;

template<bool _Const>
	struct _Sentinel;

template<bool _Const>
	struct _Iterator
	{
	private:
	  using _Parent = __detail::__maybe_const_t<_Const, join_view>;
	  using _Base = __detail::__maybe_const_t<_Const, _Vp>;

static constexpr bool _S_ref_is_glvalue
	    = is_reference_v<range_reference_t<_Base>>;

constexpr void
	  _M_satisfy()
	  {
	    auto __update_inner = [this] (range_reference_t<_Base> __x) -> auto&
	    {
	      if constexpr (_S_ref_is_glvalue)
		return __x;
	      else
		return (_M_parent->_M_inner = views::all(std::move(__x)));
	    };

for (; _M_outer != ranges::end(_M_parent->_M_base); ++_M_outer)
	      {
		auto& __inner = __update_inner(*_M_outer);
		_M_inner = ranges::begin(__inner);
		if (_M_inner != ranges::end(__inner))
		  return;
	      }

if constexpr (_S_ref_is_glvalue)
	      _M_inner = _Inner_iter();
	  }

static constexpr auto
	  _S_iter_concept()
	  {
	    if constexpr (_S_ref_is_glvalue
			  && bidirectional_range<_Base>
			  && bidirectional_range<range_reference_t<_Base>>)
	      return bidirectional_iterator_tag{};
	    else if constexpr (_S_ref_is_glvalue
			       && forward_range<_Base>
			       && forward_range<range_reference_t<_Base>>)
	      return forward_iterator_tag{};
	    else
	      return input_iterator_tag{};
	  }

static constexpr auto
	  _S_iter_cat()
	  {
	    using _OuterCat
	      = typename iterator_traits<_Outer_iter>::iterator_category;
	    using _InnerCat
	      = typename iterator_traits<_Inner_iter>::iterator_category;
	    if constexpr (_S_ref_is_glvalue
			  && derived_from<_OuterCat, bidirectional_iterator_tag>
			  && derived_from<_InnerCat, bidirectional_iterator_tag>)
	      return bidirectional_iterator_tag{};
	    else if constexpr (_S_ref_is_glvalue
			       && derived_from<_OuterCat, forward_iterator_tag>
			       && derived_from<_InnerCat, forward_iterator_tag>)
	      return forward_iterator_tag{};
	    else if constexpr (derived_from<_OuterCat, input_iterator_tag>
			       && derived_from<_InnerCat, input_iterator_tag>)
	      return input_iterator_tag{};
	    else
	      return output_iterator_tag{};
	  }

using _Outer_iter = iterator_t<_Base>;
	  using _Inner_iter = iterator_t<range_reference_t<_Base>>;

_Outer_iter _M_outer = _Outer_iter();
	  _Inner_iter _M_inner = _Inner_iter();
	  _Parent* _M_parent = nullptr;

public:
	  using iterator_concept = decltype(_S_iter_concept());
	  using iterator_category = decltype(_S_iter_cat());
	  using value_type = range_value_t<range_reference_t<_Base>>;
	  using difference_type
	    = common_type_t<range_difference_t<_Base>,
			    range_difference_t<range_reference_t<_Base>>>;

_Iterator() = default;

constexpr
	  _Iterator(_Parent& __parent, _Outer_iter __outer)
	    : _M_outer(std::move(__outer)),
	      _M_parent(std::__addressof(__parent))
	  { _M_satisfy(); }

constexpr
	  _Iterator(_Iterator<!_Const> __i)
	    requires _Const
	      && convertible_to<iterator_t<_Vp>, _Outer_iter>
	      && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
	    : _M_outer(std::move(__i._M_outer)), _M_inner(__i._M_inner),
	      _M_parent(__i._M_parent)
	  { }

constexpr decltype(auto)
	  operator*() const
	  { return *_M_inner; }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
	  // 3500. join_view::iterator::operator->() is bogus
	  constexpr _Inner_iter
	  operator->() const
	    requires __detail::__has_arrow<_Inner_iter>
	      && copyable<_Inner_iter>
	  { return _M_inner; }

constexpr _Iterator&
	  operator++()
	  {
	    auto&& __inner_range = [this] () -> decltype(auto) {
	      if constexpr (_S_ref_is_glvalue)
		return *_M_outer;
	      else
		return _M_parent->_M_inner;
	    }();
	    if (++_M_inner == ranges::end(__inner_range))
	      {
		++_M_outer;
		_M_satisfy();
	      }
	    return *this;
	  }

constexpr void
	  operator++(int)
	  { ++*this; }

constexpr _Iterator
	  operator++(int)
	    requires _S_ref_is_glvalue && forward_range<_Base>
	      && forward_range<range_reference_t<_Base>>
	  {
	    auto __tmp = *this;
	    ++*this;
	    return __tmp;
	  }

constexpr _Iterator&
	  operator--()
	    requires _S_ref_is_glvalue && bidirectional_range<_Base>
	      && bidirectional_range<range_reference_t<_Base>>
	      && common_range<range_reference_t<_Base>>
	  {
	    if (_M_outer == ranges::end(_M_parent->_M_base))
	      _M_inner = ranges::end(*--_M_outer);
	    while (_M_inner == ranges::begin(*_M_outer))
	      _M_inner = ranges::end(*--_M_outer);
	    --_M_inner;
	    return *this;
	  }

constexpr _Iterator
	  operator--(int)
	    requires _S_ref_is_glvalue && bidirectional_range<_Base>
	      && bidirectional_range<range_reference_t<_Base>>
	      && common_range<range_reference_t<_Base>>
	  {
	    auto __tmp = *this;
	    --*this;
	    return __tmp;
	  }

friend constexpr bool
	  operator==(const _Iterator& __x, const _Iterator& __y)
	    requires _S_ref_is_glvalue
	      && equality_comparable<_Outer_iter>
	      && equality_comparable<_Inner_iter>
	  {
	    return (__x._M_outer == __y._M_outer
		    && __x._M_inner == __y._M_inner);
	  }

friend constexpr decltype(auto)
	  iter_move(const _Iterator& __i)
	  noexcept(noexcept(ranges::iter_move(__i._M_inner)))
	  { return ranges::iter_move(__i._M_inner); }

friend constexpr void
	  iter_swap(const _Iterator& __x, const _Iterator& __y)
	    noexcept(noexcept(ranges::iter_swap(__x._M_inner, __y._M_inner)))
	  { return ranges::iter_swap(__x._M_inner, __y._M_inner); }

friend _Iterator<!_Const>;
	  template<bool> friend struct _Sentinel;
	};

template<bool _Const>
	struct _Sentinel
	{
	private:
	  using _Parent = __detail::__maybe_const_t<_Const, join_view>;
	  using _Base = __detail::__maybe_const_t<_Const, _Vp>;

template<bool _Const2>
	    constexpr bool
	    __equal(const _Iterator<_Const2>& __i) const
	    { return __i._M_outer == _M_end; }

sentinel_t<_Base> _M_end = sentinel_t<_Base>();

public:
	  _Sentinel() = default;

constexpr explicit
	  _Sentinel(_Parent& __parent)
	    : _M_end(ranges::end(__parent._M_base))
	  { }

constexpr
	  _Sentinel(_Sentinel<!_Const> __s)
	    requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
	    : _M_end(std::move(__s._M_end))
	  { }

friend _Sentinel<!_Const>;
	};

_Vp _M_base = _Vp();

// XXX: _M_inner is "present only when !is_reference_v<_InnerRange>"
      [[no_unique_address]]
	__detail::__maybe_present_t<!is_reference_v<_InnerRange>,
				    views::all_t<_InnerRange>> _M_inner;

public:
      join_view() = default;

constexpr explicit
      join_view(_Vp __base)
	: _M_base(std::move(__base))
      { }

constexpr _Vp
      base() const& requires copy_constructible<_Vp>
      { return _M_base; }

constexpr _Vp
      base() &&
      { return std::move(_M_base); }

constexpr auto
      begin()
      {
	constexpr bool __use_const
	  = (__detail::__simple_view<_Vp>
	     && is_reference_v<range_reference_t<_Vp>>);
	return _Iterator<__use_const>{*this, ranges::begin(_M_base)};
      }

constexpr auto
      begin() const
	requires input_range<const _Vp>
	  && is_reference_v<range_reference_t<const _Vp>>
      {
	return _Iterator<true>{*this, ranges::begin(_M_base)};
      }

constexpr auto
      end()
      {
	if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
		      && forward_range<_InnerRange>
		      && common_range<_Vp> && common_range<_InnerRange>)
	  return _Iterator<__detail::__simple_view<_Vp>>{*this,
							 ranges::end(_M_base)};
	else
	  return _Sentinel<__detail::__simple_view<_Vp>>{*this};
      }

constexpr auto
      end() const
	requires input_range<const _Vp>
	  && is_reference_v<range_reference_t<const _Vp>>
      {
	if constexpr (forward_range<const _Vp>
		      && is_reference_v<range_reference_t<const _Vp>>
		      && forward_range<range_reference_t<const _Vp>>
		      && common_range<const _Vp>
		      && common_range<range_reference_t<const _Vp>>)
	  return _Iterator<true>{*this, ranges::end(_M_base)};
	else
	  return _Sentinel<true>{*this};
      }
    };

template<typename _Range>
    explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;

namespace views
  {
    inline constexpr __adaptor::_RangeAdaptorClosure join
      = [] <viewable_range _Range> (_Range&& __r)
      {
	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	// 3474. Nesting join_views is broken because of CTAD
	return join_view<views::all_t<_Range>>{std::forward<_Range>(__r)};
      };
  } // namespace views

namespace __detail
  {
    template<auto>
      struct __require_constant;

template<typename _Range>
      concept __tiny_range = sized_range<_Range>
	&& requires
	   { typename __require_constant<remove_reference_t<_Range>::size()>; }
	&& (remove_reference_t<_Range>::size() <= 1);
  }

template<input_range _Vp, forward_range _Pattern>
    requires view<_Vp> && view<_Pattern>
      && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
			       ranges::equal_to>
      && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
    class split_view : public view_interface<split_view<_Vp, _Pattern>>
    {
    private:
      template<bool _Const>
	struct _InnerIter;

template<bool _Const>
	struct _OuterIter
	{
	private:
	  using _Parent = __detail::__maybe_const_t<_Const, split_view>;
	  using _Base = __detail::__maybe_const_t<_Const, _Vp>;

constexpr bool
	  __at_end() const
	  { return __current() == ranges::end(_M_parent->_M_base); }

// [range.split.outer] p1
	  //  Many of the following specifications refer to the notional member
	  //  current of outer-iterator.  current is equivalent to current_ if
	  //  V models forward_range, and parent_->current_ otherwise.
	  constexpr auto&
	  __current() noexcept
	  {
	    if constexpr (forward_range<_Vp>)
	      return _M_current;
	    else
	      return _M_parent->_M_current;
	  }

constexpr auto&
	  __current() const noexcept
	  {
	    if constexpr (forward_range<_Vp>)
	      return _M_current;
	    else
	      return _M_parent->_M_current;
	  }

_Parent* _M_parent = nullptr;

// XXX: _M_current is present only if "V models forward_range"
	  [[no_unique_address]]
	    __detail::__maybe_present_t<forward_range<_Vp>,
					iterator_t<_Base>> _M_current;

public:
	  using iterator_concept = conditional_t<forward_range<_Base>,
						 forward_iterator_tag,
						 input_iterator_tag>;
	  using iterator_category = input_iterator_tag;
	  using difference_type = range_difference_t<_Base>;

struct value_type : view_interface<value_type>
	  {
	  private:
	    _OuterIter _M_i = _OuterIter();

public:
	    value_type() = default;

constexpr explicit
	    value_type(_OuterIter __i)
	      : _M_i(std::move(__i))
	    { }

constexpr _InnerIter<_Const>
	    begin() const
	      requires copyable<_OuterIter>
	    { return _InnerIter<_Const>{_M_i}; }

constexpr _InnerIter<_Const>
	    begin()
	      requires (!copyable<_OuterIter>)
	    { return _InnerIter<_Const>{std::move(_M_i)}; }

constexpr default_sentinel_t
	    end() const
	    { return default_sentinel; }
	  };

_OuterIter() = default;

constexpr explicit
	  _OuterIter(_Parent& __parent) requires (!forward_range<_Base>)
	    : _M_parent(std::__addressof(__parent))
	  { }

constexpr
	  _OuterIter(_Parent& __parent, iterator_t<_Base> __current)
	    requires forward_range<_Base>
	    : _M_parent(std::__addressof(__parent)),
	      _M_current(std::move(__current))
	  { }

constexpr
	  _OuterIter(_OuterIter<!_Const> __i)
	    requires _Const
	      && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
	    : _M_parent(__i._M_parent), _M_current(std::move(__i._M_current))
	  { }

constexpr value_type
	  operator*() const
	  { return value_type{*this}; }

constexpr _OuterIter&
	  operator++()
	  {
	    const auto __end = ranges::end(_M_parent->_M_base);
	    if (__current() == __end)
	      return *this;
	    const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
	    if (__pbegin == __pend)
	      ++__current();
	    else
	      do
		{
		  auto [__b, __p]
		    = __detail::mismatch(std::move(__current()), __end,
					 __pbegin, __pend);
		  __current() = std::move(__b);
		  if (__p == __pend)
		    break;
		} while (++__current() != __end);
	    return *this;
	  }

constexpr decltype(auto)
	  operator++(int)
	  {
	    if constexpr (forward_range<_Base>)
	      {
		auto __tmp = *this;
		++*this;
		return __tmp;
	      }
	    else
	      ++*this;
	  }

friend constexpr bool
	  operator==(const _OuterIter& __x, const _OuterIter& __y)
	    requires forward_range<_Base>
	  { return __x._M_current == __y._M_current; }

friend constexpr bool
	  operator==(const _OuterIter& __x, default_sentinel_t)
	  { return __x.__at_end(); };

friend _OuterIter<!_Const>;
	  friend _InnerIter<_Const>;
	};

template<bool _Const>
	struct _InnerIter
	{
	private:
	  using _Base = __detail::__maybe_const_t<_Const, _Vp>;

constexpr bool
	  __at_end() const
	  {
	    auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
	    auto __end = ranges::end(_M_i._M_parent->_M_base);
	    if constexpr (__detail::__tiny_range<_Pattern>)
	      {
		const auto& __cur = _M_i_current();
		if (__cur == __end)
		  return true;
		if (__pcur == __pend)
		  return _M_incremented;
		return *__cur == *__pcur;
	      }
	    else
	      {
		auto __cur = _M_i_current();
		if (__cur == __end)
		  return true;
		if (__pcur == __pend)
		  return _M_incremented;
		do
		  {
		    if (*__cur != *__pcur)
		      return false;
		    if (++__pcur == __pend)
		      return true;
		  } while (++__cur != __end);
		return false;
	      }
	  }

static constexpr auto
	  _S_iter_cat()
	  {
	    using _Cat
              = typename iterator_traits<iterator_t<_Base>>::iterator_category;
	    if constexpr (derived_from<_Cat, forward_iterator_tag>)
	      return forward_iterator_tag{};
	    else
	      return _Cat{};
	  }

constexpr auto&
	  _M_i_current() noexcept
	  { return _M_i.__current(); }

constexpr auto&
	  _M_i_current() const noexcept
	  { return _M_i.__current(); }

_OuterIter<_Const> _M_i = _OuterIter<_Const>();
	  bool _M_incremented = false;

public:
	  using iterator_concept
	    = typename _OuterIter<_Const>::iterator_concept;
	  using iterator_category = decltype(_S_iter_cat());
	  using value_type = range_value_t<_Base>;
	  using difference_type = range_difference_t<_Base>;

_InnerIter() = default;

constexpr explicit
	  _InnerIter(_OuterIter<_Const> __i)
	    : _M_i(std::move(__i))
	  { }

constexpr decltype(auto)
	  operator*() const
	  { return *_M_i_current(); }

constexpr _InnerIter&
	  operator++()
	  {
	    _M_incremented = true;
	    if constexpr (!forward_range<_Base>)
	      if constexpr (_Pattern::size() == 0)
		return *this;
	    ++_M_i_current();
	    return *this;
	  }

constexpr decltype(auto)
	  operator++(int)
	  {
	    if constexpr (forward_range<_Vp>)
	      {
		auto __tmp = *this;
		++*this;
		return __tmp;
	      }
	    else
	      ++*this;
	  }

friend constexpr bool
	  operator==(const _InnerIter& __x, const _InnerIter& __y)
	    requires forward_range<_Base>
	  { return __x._M_i == __y._M_i; }

friend constexpr bool
	  operator==(const _InnerIter& __x, default_sentinel_t)
	  { return __x.__at_end(); }

friend constexpr decltype(auto)
	  iter_move(const _InnerIter& __i)
	    noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
	  { return ranges::iter_move(__i._M_i_current()); }

friend constexpr void
	  iter_swap(const _InnerIter& __x, const _InnerIter& __y)
	    noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
						__y._M_i_current())))
	    requires indirectly_swappable<iterator_t<_Base>>
	  { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
	};

_Vp _M_base = _Vp();
      _Pattern _M_pattern = _Pattern();

// XXX: _M_current is "present only if !forward_range<V>"
      [[no_unique_address]]
	__detail::__maybe_present_t<!forward_range<_Vp>, iterator_t<_Vp>>
	  _M_current;

public:
      split_view() = default;

constexpr
      split_view(_Vp __base, _Pattern __pattern)
	: _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
      { }

template<input_range _Range>
	requires constructible_from<_Vp, views::all_t<_Range>>
	  && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
	constexpr
	split_view(_Range&& __r, range_value_t<_Range> __e)
	  : _M_base(views::all(std::forward<_Range>(__r))),
	    _M_pattern(std::move(__e))
	{ }

constexpr _Vp
      base() const& requires copy_constructible<_Vp>
      { return _M_base; }

constexpr _Vp
      base() &&
      { return std::move(_M_base); }

constexpr auto
      begin()
      {
	if constexpr (forward_range<_Vp>)
	  return _OuterIter<__detail::__simple_view<_Vp>>{
	      *this, ranges::begin(_M_base)};
	else
	  {
	    _M_current = ranges::begin(_M_base);
	    return _OuterIter<false>{*this};
	  }
      }

constexpr auto
      begin() const requires forward_range<_Vp> && forward_range<const _Vp>
      {
	return _OuterIter<true>{*this, ranges::begin(_M_base)};
      }

constexpr auto
      end() requires forward_range<_Vp> && common_range<_Vp>
      {
	return _OuterIter<__detail::__simple_view<_Vp>>{
	    *this, ranges::end(_M_base)};
      }

constexpr auto
      end() const
      {
	if constexpr (forward_range<_Vp>
		      && forward_range<const _Vp>
		      && common_range<const _Vp>)
	  return _OuterIter<true>{*this, ranges::end(_M_base)};
	else
	  return default_sentinel;
      }
    };

template<typename _Range, typename _Pred>
    split_view(_Range&&, _Pred&&)
      -> split_view<views::all_t<_Range>, views::all_t<_Pred>>;

template<input_range _Range>
    split_view(_Range&&, range_value_t<_Range>)
      -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;

namespace views
  {
    inline constexpr __adaptor::_RangeAdaptor split
      = [] <viewable_range _Range, typename _Fp> (_Range&& __r, _Fp&& __f)
      {
	return split_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)};
      };
  } // namespace views

namespace views
  {
    struct _Counted
    {
      template<input_or_output_iterator _Iter>
      constexpr auto
      operator()(_Iter __i, iter_difference_t<_Iter> __n) const
      {
	if constexpr (random_access_iterator<_Iter>)
	  return subrange{__i, __i + __n};
	else
	  return subrange{counted_iterator{std::move(__i), __n},
			  default_sentinel};
      }
    };

inline constexpr _Counted counted{};
  } // namespace views

template<view _Vp>
    requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
    class common_view : public view_interface<common_view<_Vp>>
    {
    private:
      _Vp _M_base = _Vp();

public:
      common_view() = default;

constexpr explicit
      common_view(_Vp __r)
	: _M_base(std::move(__r))
      { }

/* XXX: LWG 3280 didn't remove this constructor, but I think it should?
      template<viewable_range _Range>
	requires (!common_range<_Range>)
	  && constructible_from<_Vp, views::all_t<_Range>>
	constexpr explicit
	common_view(_Range&& __r)
	  : _M_base(views::all(std::forward<_Range>(__r)))
	{ }
      */

constexpr _Vp
      base() const& requires copy_constructible<_Vp>
      { return _M_base; }

constexpr _Vp
      base() &&
      { return std::move(_M_base); }

constexpr auto
      begin()
      {
	if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
	  return ranges::begin(_M_base);
	else
	  return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
		  (ranges::begin(_M_base));
      }

constexpr auto
      begin() const requires range<const _Vp>
      {
	if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
	  return ranges::begin(_M_base);
	else
	  return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
		  (ranges::begin(_M_base));
      }

constexpr auto
      end()
      {
	if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
	  return ranges::begin(_M_base) + ranges::size(_M_base);
	else
	  return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
		  (ranges::end(_M_base));
      }

constexpr auto
      end() const requires range<const _Vp>
      {
	if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
	  return ranges::begin(_M_base) + ranges::size(_M_base);
	else
	  return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
		  (ranges::end(_M_base));
      }

constexpr auto
      size() requires sized_range<_Vp>
      { return ranges::size(_M_base); }

constexpr auto
      size() const requires sized_range<const _Vp>
      { return ranges::size(_M_base); }
    };

template<typename _Range>
    common_view(_Range&&) -> common_view<views::all_t<_Range>>;

namespace views
  {
    inline constexpr __adaptor::_RangeAdaptorClosure common
      = [] <viewable_range _Range> (_Range&& __r)
      {
	if constexpr (common_range<_Range>
		      && requires { views::all(std::forward<_Range>(__r)); })
	  return views::all(std::forward<_Range>(__r));
	else
	  return common_view{std::forward<_Range>(__r)};
      };

} // namespace views

template<view _Vp>
    requires bidirectional_range<_Vp>
    class reverse_view : public view_interface<reverse_view<_Vp>>
    {
    private:
      _Vp _M_base = _Vp();

static constexpr bool _S_needs_cached_begin
	= !common_range<_Vp> && !random_access_range<_Vp>;
      [[no_unique_address]]
	__detail::__maybe_present_t<_S_needs_cached_begin,
				    __detail::_CachedPosition<_Vp>>
				      _M_cached_begin;

public:
      reverse_view() = default;

constexpr explicit
      reverse_view(_Vp __r)
	: _M_base(std::move(__r))
	{ }

constexpr _Vp
      base() const& requires copy_constructible<_Vp>
      { return _M_base; }

constexpr _Vp
      base() &&
      { return std::move(_M_base); }

constexpr reverse_iterator<iterator_t<_Vp>>
      begin()
      {
	if constexpr (_S_needs_cached_begin)
	  if (_M_cached_begin._M_has_value())
	    return make_reverse_iterator(_M_cached_begin._M_get(_M_base));

auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base));
	if constexpr (_S_needs_cached_begin)
	  _M_cached_begin._M_set(_M_base, __it);
	return make_reverse_iterator(std::move(__it));
      }

constexpr auto
      begin() requires common_range<_Vp>
      { return make_reverse_iterator(ranges::end(_M_base)); }

constexpr auto
      begin() const requires common_range<const _Vp>
      { return make_reverse_iterator(ranges::end(_M_base)); }

constexpr reverse_iterator<iterator_t<_Vp>>
      end()
      { return make_reverse_iterator(ranges::begin(_M_base)); }

constexpr auto
      end() const requires common_range<const _Vp>
      { return make_reverse_iterator(ranges::begin(_M_base)); }

constexpr auto
      size() requires sized_range<_Vp>
      { return ranges::size(_M_base); }

constexpr auto
      size() const requires sized_range<const _Vp>
      { return ranges::size(_M_base); }
    };

template<typename _Range>
    reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;

namespace views
  {
    namespace __detail
    {
      template<typename>
	inline constexpr bool __is_reversible_subrange = false;

template<typename _Iter, subrange_kind _Kind>
	inline constexpr bool
	  __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
					    reverse_iterator<_Iter>,
					    _Kind>> = true;

template<typename>
	inline constexpr bool __is_reverse_view = false;

template<typename _Vp>
	inline constexpr bool __is_reverse_view<reverse_view<_Vp>> = true;
    }

inline constexpr __adaptor::_RangeAdaptorClosure reverse
      = [] <viewable_range _Range> (_Range&& __r)
      {
	using _Tp = remove_cvref_t<_Range>;
	if constexpr (__detail::__is_reverse_view<_Tp>)
	  return std::forward<_Range>(__r).base();
	else if constexpr (__detail::__is_reversible_subrange<_Tp>)
	  {
	    using _Iter = decltype(ranges::begin(__r).base());
	    if constexpr (sized_range<_Tp>)
	      return subrange<_Iter, _Iter, subrange_kind::sized>
		      (__r.end().base(), __r.begin().base(), __r.size());
	    else
	      return subrange<_Iter, _Iter, subrange_kind::unsized>
		      (__r.end().base(), __r.begin().base());
	  }
	else
	  return reverse_view{std::forward<_Range>(__r)};
      };
  } // namespace views

namespace __detail
  {
    template<typename _Tp, size_t _Nm>
    concept __has_tuple_element = requires(_Tp __t)
      {
	typename tuple_size<_Tp>::type;
	requires _Nm < tuple_size_v<_Tp>;
	typename tuple_element_t<_Nm, _Tp>;
	{ std::get<_Nm>(__t) }
	  -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
      };
  }

template<input_range _Vp, size_t _Nm>
    requires view<_Vp>
      && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
      && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
				       _Nm>
    class elements_view : public view_interface<elements_view<_Vp, _Nm>>
    {
    public:
      elements_view() = default;

constexpr explicit
      elements_view(_Vp base)
	: _M_base(std::move(base))
      { }

constexpr _Vp
      base() const& requires copy_constructible<_Vp>
      { return _M_base; }

constexpr _Vp
      base() &&
      { return std::move(_M_base); }

constexpr auto
      begin() requires (!__detail::__simple_view<_Vp>)
      { return _Iterator<false>(ranges::begin(_M_base)); }

constexpr auto
      begin() const requires range<const _Vp>
      { return _Iterator<true>(ranges::begin(_M_base)); }

constexpr auto
      end() requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
      { return _Sentinel<false>{ranges::end(_M_base)}; }

constexpr auto
      end() requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
      { return _Iterator<false>{ranges::end(_M_base)}; }

constexpr auto
      end() const requires range<const _Vp>
      { return _Sentinel<true>{ranges::end(_M_base)}; }

constexpr auto
      end() const requires common_range<const _Vp>
      { return _Iterator<true>{ranges::end(_M_base)}; }

constexpr auto
      size() requires sized_range<_Vp>
      { return ranges::size(_M_base); }

constexpr auto
      size() const requires sized_range<const _Vp>
      { return ranges::size(_M_base); }

private:
      template<bool _Const>
	struct _Sentinel;

template<bool _Const>
	struct _Iterator
	{
	  using _Base = __detail::__maybe_const_t<_Const, _Vp>;

iterator_t<_Base> _M_current = iterator_t<_Base>();

friend _Iterator<!_Const>;

public:
	  using iterator_category
	    = typename iterator_traits<iterator_t<_Base>>::iterator_category;
	  using value_type
	    = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
	  using difference_type = range_difference_t<_Base>;

_Iterator() = default;

constexpr explicit
	  _Iterator(iterator_t<_Base> current)
	    : _M_current(std::move(current))
	  { }

constexpr
	  _Iterator(_Iterator<!_Const> i)
	    requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
	    : _M_current(std::move(i._M_current))
	  { }

constexpr iterator_t<_Base>
	  base() const&
	    requires copyable<iterator_t<_Base>>
	  { return _M_current; }

constexpr iterator_t<_Base>
	  base() &&
	  { return std::move(_M_current); }

constexpr decltype(auto)
	    operator*() const
	  { return std::get<_Nm>(*_M_current); }

constexpr _Iterator&
	  operator++()
	  {
	    ++_M_current;
	    return *this;
	  }

constexpr void
	  operator++(int) requires (!forward_range<_Base>)
	  { ++_M_current; }

constexpr _Iterator
	  operator++(int) requires forward_range<_Base>
	  {
	    auto __tmp = *this;
	    ++_M_current;
	    return __tmp;
	  }

constexpr _Iterator&
	  operator--() requires bidirectional_range<_Base>
	  {
	    --_M_current;
	    return *this;
	  }

constexpr _Iterator
	  operator--(int) requires bidirectional_range<_Base>
	  {
	    auto __tmp = *this;
	    --_M_current;
	    return __tmp;
	  }

constexpr _Iterator&
	  operator+=(difference_type __n)
	    requires random_access_range<_Base>
	  {
	    _M_current += __n;
	    return *this;
	  }

constexpr _Iterator&
	  operator-=(difference_type __n)
	    requires random_access_range<_Base>
	  {
	    _M_current -= __n;
	    return *this;
	  }

constexpr decltype(auto)
	  operator[](difference_type __n) const
	    requires random_access_range<_Base>
	  { return std::get<_Nm>(*(_M_current + __n)); }

friend constexpr bool
	  operator==(const _Iterator& __x, const _Iterator& __y)
	    requires equality_comparable<iterator_t<_Base>>
	  { return __x._M_current == __y._M_current; }

friend constexpr bool
	  operator<(const _Iterator& __x, const _Iterator& __y)
	    requires random_access_range<_Base>
	  { return __x._M_current < __y._M_current; }

friend constexpr bool
	  operator>(const _Iterator& __x, const _Iterator& __y)
	    requires random_access_range<_Base>
	  { return __y._M_current < __x._M_current; }

friend constexpr bool
	  operator<=(const _Iterator& __x, const _Iterator& __y)
	    requires random_access_range<_Base>
	  { return !(__y._M_current > __x._M_current); }

friend constexpr bool
	  operator>=(const _Iterator& __x, const _Iterator& __y)
	    requires random_access_range<_Base>
	  { return !(__x._M_current > __y._M_current); }

#ifdef __cpp_lib_three_way_comparison
	  friend constexpr auto
	  operator<=>(const _Iterator& __x, const _Iterator& __y)
	    requires random_access_range<_Base>
	      && three_way_comparable<iterator_t<_Base>>
	  { return __x._M_current <=> __y._M_current; }
#endif

friend constexpr _Iterator
	  operator+(const _Iterator& __x, difference_type __y)
	    requires random_access_range<_Base>
	  { return _Iterator{__x} += __y; }

friend constexpr _Iterator
	  operator+(difference_type __x, const _Iterator& __y)
	    requires random_access_range<_Base>
	  { return __y + __x; }

friend constexpr _Iterator
	  operator-(const _Iterator& __x, difference_type __y)
	    requires random_access_range<_Base>
	  { return _Iterator{__x} -= __y; }

friend constexpr difference_type
	  operator-(const _Iterator& __x, const _Iterator& __y)
	    requires random_access_range<_Base>
	  { return __x._M_current - __y._M_current; }

friend _Sentinel<_Const>;
	};

template<bool _Const>
	struct _Sentinel
	{
	private:
	  constexpr bool
	  _M_equal(const _Iterator<_Const>& __x) const
	  { return __x._M_current == _M_end; }

using _Base = __detail::__maybe_const_t<_Const, _Vp>;
	  sentinel_t<_Base> _M_end = sentinel_t<_Base>();

public:
	  _Sentinel() = default;

constexpr explicit
	  _Sentinel(sentinel_t<_Base> __end)
	    : _M_end(std::move(__end))
	  { }

constexpr
	  _Sentinel(_Sentinel<!_Const> __other)
	    requires _Const
	      && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
	    : _M_end(std::move(__other._M_end))
	  { }

constexpr sentinel_t<_Base>
	  base() const
	  { return _M_end; }

template<bool _Const2,
		   typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
	    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
	    friend constexpr range_difference_t<_Base>
	    operator-(const _Sentinel& __x, const _Iterator<_Const2>& __y)
	    { return __x._M_end - __y._M_current; }

friend _Sentinel<!_Const>;
	};

_Vp _M_base = _Vp();
    };

template<typename _Range>
    using keys_view = elements_view<views::all_t<_Range>, 0>;

template<typename _Range>
    using values_view = elements_view<views::all_t<_Range>, 1>;

namespace views
  {
    template<size_t _Nm>
    inline constexpr __adaptor::_RangeAdaptorClosure elements
      = [] <viewable_range _Range> (_Range&& __r)
      {
	using _El = elements_view<views::all_t<_Range>, _Nm>;
	return _El{std::forward<_Range>(__r)};
      };

inline constexpr __adaptor::_RangeAdaptorClosure keys = elements<0>;
    inline constexpr __adaptor::_RangeAdaptorClosure values = elements<1>;
  } // namespace views

} // namespace ranges

namespace views = ranges::views;

template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
    struct tuple_size<ranges::subrange<_Iter, _Sent, _Kind>>
    : integral_constant<size_t, 2>
    { };

template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
    struct tuple_element<0, ranges::subrange<_Iter, _Sent, _Kind>>
    { using type = _Iter; };

template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
    struct tuple_element<1, ranges::subrange<_Iter, _Sent, _Kind>>
    { using type = _Sent; };

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

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

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
#endif // library concepts
#endif // C++2a
#endif /* _GLIBCXX_RANGES */

./Ninja\.