Where Online Learning is simpler!

The C and C++ Include Header Files

/usr/include/c++/13/ranges


$ cat -n /usr/include/c++/13/ranges

     1	// <ranges> -*- C++ -*-
     2	
     3	// Copyright (C) 2019-2023 Free Software Foundation, Inc.
     4	//
     5	// This file is part of the GNU ISO C++ Library.  This library is free
     6	// software; you can redistribute it and/or modify it under the
     7	// terms of the GNU General Public License as published by the
     8	// Free Software Foundation; either version 3, or (at your option)
     9	// any later version.
    10	
    11	// This library is distributed in the hope that it will be useful,
    12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
    13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    14	// GNU General Public License for more details.
    15	
    16	// Under Section 7 of GPL version 3, you are granted additional
    17	// permissions described in the GCC Runtime Library Exception, version
    18	// 3.1, as published by the Free Software Foundation.
    19	
    20	// You should have received a copy of the GNU General Public License and
    21	// a copy of the GCC Runtime Library Exception along with this program;
    22	// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    23	// <http://www.gnu.org/licenses/>.
    24	
    25	/** @file include/ranges
    26	 *  This is a Standard C++ Library header.
    27	 *  @ingroup concepts
    28	 */
    29	
    30	#ifndef _GLIBCXX_RANGES
    31	#define _GLIBCXX_RANGES 1
    32	
    33	#if __cplusplus > 201703L
    34	
    35	#pragma GCC system_header
    36	
    37	#include <concepts>
    38	
    39	#if __cpp_lib_concepts
    40	
    41	#include <compare>
    42	#include <initializer_list>
    43	#include <iterator>
    44	#include <optional>
    45	#include <span>
    46	#include <string_view>
    47	#include <tuple>
    48	#if __cplusplus > 202002L
    49	#include <variant>
    50	#endif
    51	#include <bits/ranges_util.h>
    52	#include <bits/refwrap.h>
    53	
    54	/**
    55	 * @defgroup ranges Ranges
    56	 *
    57	 * Components for dealing with ranges of elements.
    58	 */
    59	
    60	namespace std _GLIBCXX_VISIBILITY(default)
    61	{
    62	_GLIBCXX_BEGIN_NAMESPACE_VERSION
    63	namespace ranges
    64	{
    65	  // [range.access] customization point objects
    66	  // [range.req] range and view concepts
    67	  // [range.dangling] dangling iterator handling
    68	  // Defined in <bits/ranges_base.h>
    69	
    70	  // [view.interface] View interface
    71	  // [range.subrange] Sub-ranges
    72	  // Defined in <bits/ranges_util.h>
    73	
    74	  // C++20 24.6 [range.factories] Range factories
    75	
    76	  /// A view that contains no elements.
    77	  template<typename _Tp> requires is_object_v<_Tp>
    78	    class empty_view
    79	    : public view_interface<empty_view<_Tp>>
    80	    {
    81	    public:
    82	      static constexpr _Tp* begin() noexcept { return nullptr; }
    83	      static constexpr _Tp* end() noexcept { return nullptr; }
    84	      static constexpr _Tp* data() noexcept { return nullptr; }
    85	      static constexpr size_t size() noexcept { return 0; }
    86	      static constexpr bool empty() noexcept { return true; }
    87	    };
    88	
    89	  template<typename _Tp>
    90	    inline constexpr bool enable_borrowed_range<empty_view<_Tp>> = true;
    91	
    92	  namespace __detail
    93	  {
    94	    template<typename _Tp>
    95	      concept __boxable = copy_constructible<_Tp> && is_object_v<_Tp>;
    96	
    97	    template<__boxable _Tp>
    98	      struct __box : std::optional<_Tp>
    99	      {
   100		using std::optional<_Tp>::optional;
   101	
   102		constexpr
   103		__box()
   104		noexcept(is_nothrow_default_constructible_v<_Tp>)
   105		requires default_initializable<_Tp>
   106		: std::optional<_Tp>{std::in_place}
   107		{ }
   108	
   109		__box(const __box&) = default;
   110		__box(__box&&) = default;
   111	
   112		using std::optional<_Tp>::operator=;
   113	
   114		// _GLIBCXX_RESOLVE_LIB_DEFECTS
   115		// 3477. Simplify constraints for semiregular-box
   116		// 3572. copyable-box should be fully constexpr
   117		constexpr __box&
   118		operator=(const __box& __that)
   119		noexcept(is_nothrow_copy_constructible_v<_Tp>)
   120		requires (!copyable<_Tp>)
   121		{
   122		  if (this != std::__addressof(__that))
   123		    {
   124		      if ((bool)__that)
   125			this->emplace(*__that);
   126		      else
   127			this->reset();
   128		    }
   129		  return *this;
   130		}
   131	
   132		constexpr __box&
   133		operator=(__box&& __that)
   134		noexcept(is_nothrow_move_constructible_v<_Tp>)
   135		requires (!movable<_Tp>)
   136		{
   137		  if (this != std::__addressof(__that))
   138		    {
   139		      if ((bool)__that)
   140			this->emplace(std::move(*__that));
   141		      else
   142			this->reset();
   143		    }
   144		  return *this;
   145		}
   146	      };
   147	
   148	    // For types which are already copyable, this specialization of the
   149	    // copyable wrapper stores the object directly without going through
   150	    // std::optional.  It provides just the subset of the primary template's
   151	    // API that we currently use.
   152	    template<__boxable _Tp>
   153	      requires copyable<_Tp> || (is_nothrow_move_constructible_v<_Tp>
   154					 && is_nothrow_copy_constructible_v<_Tp>)
   155	      struct __box<_Tp>
   156	      {
   157	      private:
   158		[[no_unique_address]] _Tp _M_value = _Tp();
   159	
   160	      public:
   161		__box() requires default_initializable<_Tp> = default;
   162	
   163		constexpr explicit
   164		__box(const _Tp& __t)
   165		noexcept(is_nothrow_copy_constructible_v<_Tp>)
   166		: _M_value(__t)
   167		{ }
   168	
   169		constexpr explicit
   170		__box(_Tp&& __t)
   171		noexcept(is_nothrow_move_constructible_v<_Tp>)
   172		: _M_value(std::move(__t))
   173		{ }
   174	
   175		template<typename... _Args>
   176		  requires constructible_from<_Tp, _Args...>
   177		  constexpr explicit
   178		  __box(in_place_t, _Args&&... __args)
   179		  noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
   180		  : _M_value(std::forward<_Args>(__args)...)
   181		  { }
   182	
   183		__box(const __box&) = default;
   184		__box(__box&&) = default;
   185		__box& operator=(const __box&) requires copyable<_Tp> = default;
   186		__box& operator=(__box&&) requires copyable<_Tp> = default;
   187	
   188		// When _Tp is nothrow_copy_constructible but not copy_assignable,
   189		// copy assignment is implemented via destroy-then-copy-construct.
   190		constexpr __box&
   191		operator=(const __box& __that) noexcept
   192		{
   193		  static_assert(is_nothrow_copy_constructible_v<_Tp>);
   194		  if (this != std::__addressof(__that))
   195		    {
   196		      _M_value.~_Tp();
   197		      std::construct_at(std::__addressof(_M_value), *__that);
   198		    }
   199		  return *this;
   200		}
   201	
   202		// Likewise for move assignment.
   203		constexpr __box&
   204		operator=(__box&& __that) noexcept
   205		{
   206		  static_assert(is_nothrow_move_constructible_v<_Tp>);
   207		  if (this != std::__addressof(__that))
   208		    {
   209		      _M_value.~_Tp();
   210		      std::construct_at(std::__addressof(_M_value), std::move(*__that));
   211		    }
   212		  return *this;
   213		}
   214	
   215		constexpr bool
   216		has_value() const noexcept
   217		{ return true; };
   218	
   219		constexpr _Tp&
   220		operator*() noexcept
   221		{ return _M_value; }
   222	
   223		constexpr const _Tp&
   224		operator*() const noexcept
   225		{ return _M_value; }
   226	
   227		constexpr _Tp*
   228		operator->() noexcept
   229		{ return std::__addressof(_M_value); }
   230	
   231		constexpr const _Tp*
   232		operator->() const noexcept
   233		{ return std::__addressof(_M_value); }
   234	      };
   235	  } // namespace __detail
   236	
   237	  /// A view that contains exactly one element.
   238	  template<copy_constructible _Tp> requires is_object_v<_Tp>
   239	    class single_view : public view_interface<single_view<_Tp>>
   240	    {
   241	    public:
   242	      single_view() requires default_initializable<_Tp> = default;
   243	
   244	      constexpr explicit
   245	      single_view(const _Tp& __t)
   246	      noexcept(is_nothrow_copy_constructible_v<_Tp>)
   247	      : _M_value(__t)
   248	      { }
   249	
   250	      constexpr explicit
   251	      single_view(_Tp&& __t)
   252	      noexcept(is_nothrow_move_constructible_v<_Tp>)
   253	      : _M_value(std::move(__t))
   254	      { }
   255	
   256	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
   257	      // 3428. single_view's in place constructor should be explicit
   258	      template<typename... _Args>
   259		requires constructible_from<_Tp, _Args...>
   260		constexpr explicit
   261		single_view(in_place_t, _Args&&... __args)
   262		noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
   263		: _M_value{in_place, std::forward<_Args>(__args)...}
   264		{ }
   265	
   266	      constexpr _Tp*
   267	      begin() noexcept
   268	      { return data(); }
   269	
   270	      constexpr const _Tp*
   271	      begin() const noexcept
   272	      { return data(); }
   273	
   274	      constexpr _Tp*
   275	      end() noexcept
   276	      { return data() + 1; }
   277	
   278	      constexpr const _Tp*
   279	      end() const noexcept
   280	      { return data() + 1; }
   281	
   282	      static constexpr size_t
   283	      size() noexcept
   284	      { return 1; }
   285	
   286	      constexpr _Tp*
   287	      data() noexcept
   288	      { return _M_value.operator->(); }
   289	
   290	      constexpr const _Tp*
   291	      data() const noexcept
   292	      { return _M_value.operator->(); }
   293	
   294	    private:
   295	      [[no_unique_address]] __detail::__box<_Tp> _M_value;
   296	    };
   297	
   298	  template<typename _Tp>
   299	    single_view(_Tp) -> single_view<_Tp>;
   300	
   301	  namespace __detail
   302	  {
   303	    template<typename _Wp>
   304	      constexpr auto __to_signed_like(_Wp __w) noexcept
   305	      {
   306		if constexpr (!integral<_Wp>)
   307		  return iter_difference_t<_Wp>();
   308		else if constexpr (sizeof(iter_difference_t<_Wp>) > sizeof(_Wp))
   309		  return iter_difference_t<_Wp>(__w);
   310		else if constexpr (sizeof(ptrdiff_t) > sizeof(_Wp))
   311		  return ptrdiff_t(__w);
   312		else if constexpr (sizeof(long long) > sizeof(_Wp))
   313		  return (long long)(__w);
   314	#ifdef __SIZEOF_INT128__
   315		else if constexpr (__SIZEOF_INT128__ > sizeof(_Wp))
   316		  return __int128(__w);
   317	#endif
   318		else
   319		  return __max_diff_type(__w);
   320	      }
   321	
   322	    template<typename _Wp>
   323	      using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
   324	
   325	    template<typename _It>
   326	      concept __decrementable = incrementable<_It>
   327		&& requires(_It __i)
   328		{
   329		    { --__i } -> same_as<_It&>;
   330		    { __i-- } -> same_as<_It>;
   331		};
   332	
   333	    template<typename _It>
   334	      concept __advanceable = __decrementable<_It> && totally_ordered<_It>
   335		&& requires( _It __i, const _It __j, const __iota_diff_t<_It> __n)
   336		{
   337		  { __i += __n } -> same_as<_It&>;
   338		  { __i -= __n } -> same_as<_It&>;
   339		  _It(__j + __n);
   340		  _It(__n + __j);
   341		  _It(__j - __n);
   342		  { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
   343		};
   344	
   345	    template<typename _Winc>
   346	      struct __iota_view_iter_cat
   347	      { };
   348	
   349	    template<incrementable _Winc>
   350	      struct __iota_view_iter_cat<_Winc>
   351	      { using iterator_category = input_iterator_tag; };
   352	  } // namespace __detail
   353	
   354	  template<weakly_incrementable _Winc,
   355		   semiregular _Bound = unreachable_sentinel_t>
   356	    requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
   357	      && copyable<_Winc>
   358	    class iota_view : public view_interface<iota_view<_Winc, _Bound>>
   359	    {
   360	    private:
   361	      struct _Sentinel;
   362	
   363	      struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
   364	      {
   365	      private:
   366		static auto
   367		_S_iter_concept()
   368		{
   369		  using namespace __detail;
   370		  if constexpr (__advanceable<_Winc>)
   371		    return random_access_iterator_tag{};
   372		  else if constexpr (__decrementable<_Winc>)
   373		    return bidirectional_iterator_tag{};
   374		  else if constexpr (incrementable<_Winc>)
   375		    return forward_iterator_tag{};
   376		  else
   377		    return input_iterator_tag{};
   378		}
   379	
   380	      public:
   381		using iterator_concept = decltype(_S_iter_concept());
   382		// iterator_category defined in __iota_view_iter_cat
   383		using value_type = _Winc;
   384		using difference_type = __detail::__iota_diff_t<_Winc>;
   385	
   386		_Iterator() requires default_initializable<_Winc> = default;
   387	
   388		constexpr explicit
   389		_Iterator(_Winc __value)
   390		: _M_value(__value) { }
   391	
   392		constexpr _Winc
   393		operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
   394		{ return _M_value; }
   395	
   396		constexpr _Iterator&
   397		operator++()
   398		{
   399		  ++_M_value;
   400		  return *this;
   401		}
   402	
   403		constexpr void
   404		operator++(int)
   405		{ ++*this; }
   406	
   407		constexpr _Iterator
   408		operator++(int) requires incrementable<_Winc>
   409		{
   410		  auto __tmp = *this;
   411		  ++*this;
   412		  return __tmp;
   413		}
   414	
   415		constexpr _Iterator&
   416		operator--() requires __detail::__decrementable<_Winc>
   417		{
   418		  --_M_value;
   419		  return *this;
   420		}
   421	
   422		constexpr _Iterator
   423		operator--(int) requires __detail::__decrementable<_Winc>
   424		{
   425		  auto __tmp = *this;
   426		  --*this;
   427		  return __tmp;
   428		}
   429	
   430		constexpr _Iterator&
   431		operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
   432		{
   433		  using __detail::__is_integer_like;
   434		  using __detail::__is_signed_integer_like;
   435		  if constexpr (__is_integer_like<_Winc>
   436		      && !__is_signed_integer_like<_Winc>)
   437		    {
   438		      if (__n >= difference_type(0))
   439			_M_value += static_cast<_Winc>(__n);
   440		      else
   441			_M_value -= static_cast<_Winc>(-__n);
   442		    }
   443		  else
   444		    _M_value += __n;
   445		  return *this;
   446		}
   447	
   448		constexpr _Iterator&
   449		operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
   450		{
   451		  using __detail::__is_integer_like;
   452		  using __detail::__is_signed_integer_like;
   453		  if constexpr (__is_integer_like<_Winc>
   454		      && !__is_signed_integer_like<_Winc>)
   455		    {
   456		      if (__n >= difference_type(0))
   457			_M_value -= static_cast<_Winc>(__n);
   458		      else
   459			_M_value += static_cast<_Winc>(-__n);
   460		    }
   461		  else
   462		    _M_value -= __n;
   463		  return *this;
   464		}
   465	
   466		constexpr _Winc
   467		operator[](difference_type __n) const
   468		requires __detail::__advanceable<_Winc>
   469		{ return _Winc(_M_value + __n); }
   470	
   471		friend constexpr bool
   472		operator==(const _Iterator& __x, const _Iterator& __y)
   473		requires equality_comparable<_Winc>
   474		{ return __x._M_value == __y._M_value; }
   475	
   476		friend constexpr bool
   477		operator<(const _Iterator& __x, const _Iterator& __y)
   478		requires totally_ordered<_Winc>
   479		{ return __x._M_value < __y._M_value; }
   480	
   481		friend constexpr bool
   482		operator>(const _Iterator& __x, const _Iterator& __y)
   483		  requires totally_ordered<_Winc>
   484		{ return __y < __x; }
   485	
   486		friend constexpr bool
   487		operator<=(const _Iterator& __x, const _Iterator& __y)
   488		  requires totally_ordered<_Winc>
   489		{ return !(__y < __x); }
   490	
   491		friend constexpr bool
   492		operator>=(const _Iterator& __x, const _Iterator& __y)
   493		  requires totally_ordered<_Winc>
   494		{ return !(__x < __y); }
   495	
   496	#ifdef __cpp_lib_three_way_comparison
   497		friend constexpr auto
   498		operator<=>(const _Iterator& __x, const _Iterator& __y)
   499		  requires totally_ordered<_Winc> && three_way_comparable<_Winc>
   500		{ return __x._M_value <=> __y._M_value; }
   501	#endif
   502	
   503		friend constexpr _Iterator
   504		operator+(_Iterator __i, difference_type __n)
   505		  requires __detail::__advanceable<_Winc>
   506		{
   507		  __i += __n;
   508		  return __i;
   509		}
   510	
   511		friend constexpr _Iterator
   512		operator+(difference_type __n, _Iterator __i)
   513		  requires __detail::__advanceable<_Winc>
   514		{ return __i += __n; }
   515	
   516		friend constexpr _Iterator
   517		operator-(_Iterator __i, difference_type __n)
   518		  requires __detail::__advanceable<_Winc>
   519		{
   520		  __i -= __n;
   521		  return __i;
   522		}
   523	
   524		friend constexpr difference_type
   525		operator-(const _Iterator& __x, const _Iterator& __y)
   526		  requires __detail::__advanceable<_Winc>
   527		{
   528		  using __detail::__is_integer_like;
   529		  using __detail::__is_signed_integer_like;
   530		  using _Dt = difference_type;
   531		  if constexpr (__is_integer_like<_Winc>)
   532		    {
   533		      if constexpr (__is_signed_integer_like<_Winc>)
   534			return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
   535		      else
   536			return (__y._M_value > __x._M_value)
   537			  ? _Dt(-_Dt(__y._M_value - __x._M_value))
   538			  : _Dt(__x._M_value - __y._M_value);
   539		    }
   540		  else
   541		    return __x._M_value - __y._M_value;
   542		}
   543	
   544	      private:
   545		_Winc _M_value = _Winc();
   546	
   547		friend iota_view;
   548	        friend _Sentinel;
   549	      };
   550	
   551	      struct _Sentinel
   552	      {
   553	      private:
   554		constexpr bool
   555		_M_equal(const _Iterator& __x) const
   556		{ return __x._M_value == _M_bound; }
   557	
   558		constexpr auto
   559		_M_distance_from(const _Iterator& __x) const
   560		{ return _M_bound - __x._M_value; }
   561	
   562		_Bound _M_bound = _Bound();
   563	
   564	      public:
   565		_Sentinel() = default;
   566	
   567		constexpr explicit
   568		_Sentinel(_Bound __bound)
   569		: _M_bound(__bound) { }
   570	
   571		friend constexpr bool
   572		operator==(const _Iterator& __x, const _Sentinel& __y)
   573		{ return __y._M_equal(__x); }
   574	
   575		friend constexpr iter_difference_t<_Winc>
   576		operator-(const _Iterator& __x, const _Sentinel& __y)
   577		  requires sized_sentinel_for<_Bound, _Winc>
   578		{ return -__y._M_distance_from(__x); }
   579	
   580		friend constexpr iter_difference_t<_Winc>
   581		operator-(const _Sentinel& __x, const _Iterator& __y)
   582		  requires sized_sentinel_for<_Bound, _Winc>
   583		{ return __x._M_distance_from(__y); }
   584	
   585		friend iota_view;
   586	      };
   587	
   588	      _Winc _M_value = _Winc();
   589	      [[no_unique_address]] _Bound _M_bound = _Bound();
   590	
   591	    public:
   592	      iota_view() requires default_initializable<_Winc> = default;
   593	
   594	      constexpr explicit
   595	      iota_view(_Winc __value)
   596	      : _M_value(__value)
   597	      { }
   598	
   599	      constexpr
   600	      iota_view(type_identity_t<_Winc> __value,
   601			type_identity_t<_Bound> __bound)
   602	      : _M_value(__value), _M_bound(__bound)
   603	      {
   604		if constexpr (totally_ordered_with<_Winc, _Bound>)
   605		  __glibcxx_assert( bool(__value <= __bound) );
   606	      }
   607	
   608	      constexpr
   609	      iota_view(_Iterator __first, _Iterator __last)
   610		requires same_as<_Winc, _Bound>
   611		: iota_view(__first._M_value, __last._M_value)
   612	      { }
   613	
   614	      constexpr
   615	      iota_view(_Iterator __first, unreachable_sentinel_t __last)
   616		requires same_as<_Bound, unreachable_sentinel_t>
   617		: iota_view(__first._M_value, __last)
   618	      { }
   619	
   620	      constexpr
   621	      iota_view(_Iterator __first, _Sentinel __last)
   622		requires (!same_as<_Winc, _Bound>) && (!same_as<_Bound, unreachable_sentinel_t>)
   623		: iota_view(__first._M_value, __last._M_bound)
   624	      { }
   625	
   626	      constexpr _Iterator
   627	      begin() const { return _Iterator{_M_value}; }
   628	
   629	      constexpr auto
   630	      end() const
   631	      {
   632		if constexpr (same_as<_Bound, unreachable_sentinel_t>)
   633		  return unreachable_sentinel;
   634		else
   635		  return _Sentinel{_M_bound};
   636	      }
   637	
   638	      constexpr _Iterator
   639	      end() const requires same_as<_Winc, _Bound>
   640	      { return _Iterator{_M_bound}; }
   641	
   642	      constexpr auto
   643	      size() const
   644	      requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
   645	      || (integral<_Winc> && integral<_Bound>)
   646	      || sized_sentinel_for<_Bound, _Winc>
   647	      {
   648		using __detail::__is_integer_like;
   649		using __detail::__to_unsigned_like;
   650		if constexpr (integral<_Winc> && integral<_Bound>)
   651		  {
   652		    using _Up = make_unsigned_t<decltype(_M_bound - _M_value)>;
   653		    return _Up(_M_bound) - _Up(_M_value);
   654		  }
   655		else if constexpr (__is_integer_like<_Winc>)
   656		  return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
   657		else
   658		  return __to_unsigned_like(_M_bound - _M_value);
   659	      }
   660	    };
   661	
   662	  template<typename _Winc, typename _Bound>
   663	    requires (!__detail::__is_integer_like<_Winc>
   664		|| !__detail::__is_integer_like<_Bound>
   665		|| (__detail::__is_signed_integer_like<_Winc>
   666		    == __detail::__is_signed_integer_like<_Bound>))
   667	    iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
   668	
   669	  template<typename _Winc, typename _Bound>
   670	    inline constexpr bool
   671	      enable_borrowed_range<iota_view<_Winc, _Bound>> = true;
   672	
   673	namespace views
   674	{
   675	  template<typename _Tp>
   676	    inline constexpr empty_view<_Tp> empty{};
   677	
   678	  namespace __detail
   679	  {
   680	    template<typename _Tp>
   681	      concept __can_single_view
   682		= requires { single_view<decay_t<_Tp>>(std::declval<_Tp>()); };
   683	  } // namespace __detail
   684	
   685	  struct _Single
   686	  {
   687	    template<__detail::__can_single_view _Tp>
   688	      constexpr auto
   689	      operator() [[nodiscard]] (_Tp&& __e) const
   690	      noexcept(noexcept(single_view<decay_t<_Tp>>(std::forward<_Tp>(__e))))
   691	      { return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
   692	  };
   693	
   694	  inline constexpr _Single single{};
   695	
   696	  namespace __detail
   697	  {
   698	    template<typename... _Args>
   699	      concept __can_iota_view = requires { iota_view(std::declval<_Args>()...); };
   700	  } // namespace __detail
   701	
   702	  struct _Iota
   703	  {
   704	    template<__detail::__can_iota_view _Tp>
   705	      constexpr auto
   706	      operator() [[nodiscard]] (_Tp&& __e) const
   707	      { return iota_view(std::forward<_Tp>(__e)); }
   708	
   709	    template<typename _Tp, typename _Up>
   710	      requires __detail::__can_iota_view<_Tp, _Up>
   711	      constexpr auto
   712	      operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
   713	      { return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
   714	  };
   715	
   716	  inline constexpr _Iota iota{};
   717	} // namespace views
   718	
   719	#if _GLIBCXX_HOSTED
   720	  namespace __detail
   721	  {
   722	    template<typename _Val, typename _CharT, typename _Traits>
   723	      concept __stream_extractable
   724		= requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
   725	  } // namespace __detail
   726	
   727	  template<movable _Val, typename _CharT,
   728		   typename _Traits = char_traits<_CharT>>
   729	    requires default_initializable<_Val>
   730	      && __detail::__stream_extractable<_Val, _CharT, _Traits>
   731	    class basic_istream_view
   732	    : public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
   733	    {
   734	    public:
   735	      constexpr explicit
   736	      basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
   737		: _M_stream(std::__addressof(__stream))
   738	      { }
   739	
   740	      constexpr auto
   741	      begin()
   742	      {
   743		*_M_stream >> _M_object;
   744		return _Iterator{this};
   745	      }
   746	
   747	      constexpr default_sentinel_t
   748	      end() const noexcept
   749	      { return default_sentinel; }
   750	
   751	    private:
   752	      basic_istream<_CharT, _Traits>* _M_stream;
   753	      _Val _M_object = _Val();
   754	
   755	      struct _Iterator
   756	      {
   757	      public:
   758		using iterator_concept = input_iterator_tag;
   759		using difference_type = ptrdiff_t;
   760		using value_type = _Val;
   761	
   762		constexpr explicit
   763		_Iterator(basic_istream_view* __parent) noexcept
   764		  : _M_parent(__parent)
   765		{ }
   766	
   767		_Iterator(const _Iterator&) = delete;
   768		_Iterator(_Iterator&&) = default;
   769		_Iterator& operator=(const _Iterator&) = delete;
   770		_Iterator& operator=(_Iterator&&) = default;
   771	
   772		_Iterator&
   773		operator++()
   774		{
   775		  *_M_parent->_M_stream >> _M_parent->_M_object;
   776		  return *this;
   777		}
   778	
   779		void
   780		operator++(int)
   781		{ ++*this; }
   782	
   783		_Val&
   784		operator*() const
   785		{ return _M_parent->_M_object; }
   786	
   787		friend bool
   788		operator==(const _Iterator& __x, default_sentinel_t)
   789		{ return __x._M_at_end(); }
   790	
   791	      private:
   792		basic_istream_view* _M_parent;
   793	
   794		bool
   795		_M_at_end() const
   796		{ return !*_M_parent->_M_stream; }
   797	      };
   798	
   799	      friend _Iterator;
   800	    };
   801	
   802	  template<typename _Val>
   803	    using istream_view = basic_istream_view<_Val, char>;
   804	
   805	  template<typename _Val>
   806	    using wistream_view = basic_istream_view<_Val, wchar_t>;
   807	
   808	namespace views
   809	{
   810	  namespace __detail
   811	  {
   812	    template<typename _Tp, typename _Up>
   813	    concept __can_istream_view = requires (_Up __e) {
   814	      basic_istream_view<_Tp, typename _Up::char_type, typename _Up::traits_type>(__e);
   815	    };
   816	  } // namespace __detail
   817	
   818	  template<typename _Tp>
   819	    struct _Istream
   820	    {
   821	      template<typename _CharT, typename _Traits>
   822		constexpr auto
   823		operator() [[nodiscard]] (basic_istream<_CharT, _Traits>& __e) const
   824		requires __detail::__can_istream_view<_Tp, remove_reference_t<decltype(__e)>>
   825		{ return basic_istream_view<_Tp, _CharT, _Traits>(__e); }
   826	    };
   827	
   828	  template<typename _Tp>
   829	    inline constexpr _Istream<_Tp> istream;
   830	}
   831	#endif // HOSTED
   832	
   833	  // C++20 24.7 [range.adaptors] Range adaptors
   834	
   835	namespace __detail
   836	{
   837	  struct _Empty { };
   838	
   839	  // Alias for a type that is conditionally present
   840	  // (and is an empty type otherwise).
   841	  // Data members using this alias should use [[no_unique_address]] so that
   842	  // they take no space when not needed.
   843	  template<bool _Present, typename _Tp>
   844	    using __maybe_present_t = __conditional_t<_Present, _Tp, _Empty>;
   845	
   846	  // Alias for a type that is conditionally const.
   847	  template<bool _Const, typename _Tp>
   848	    using __maybe_const_t = __conditional_t<_Const, const _Tp, _Tp>;
   849	
   850	} // namespace __detail
   851	
   852	// Shorthand for __detail::__maybe_const_t.
   853	using __detail::__maybe_const_t;
   854	
   855	namespace views::__adaptor
   856	{
   857	  // True if the range adaptor _Adaptor can be applied with _Args.
   858	  template<typename _Adaptor, typename... _Args>
   859	    concept __adaptor_invocable
   860	      = requires { std::declval<_Adaptor>()(declval<_Args>()...); };
   861	
   862	  // True if the range adaptor non-closure _Adaptor can be partially applied
   863	  // with _Args.
   864	  template<typename _Adaptor, typename... _Args>
   865	    concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
   866	      && (sizeof...(_Args) == _Adaptor::_S_arity - 1)
   867	      && (constructible_from<decay_t<_Args>, _Args> && ...);
   868	
   869	  template<typename _Adaptor, typename... _Args>
   870	    struct _Partial;
   871	
   872	  template<typename _Lhs, typename _Rhs>
   873	    struct _Pipe;
   874	
   875	  // The base class of every range adaptor closure.
   876	  //
   877	  // The derived class should define the optional static data member
   878	  // _S_has_simple_call_op to true if the behavior of this adaptor is
   879	  // independent of the constness/value category of the adaptor object.
   880	  struct _RangeAdaptorClosure
   881	  {
   882	    // range | adaptor is equivalent to adaptor(range).
   883	    template<typename _Self, typename _Range>
   884	      requires derived_from<remove_cvref_t<_Self>, _RangeAdaptorClosure>
   885		&& __adaptor_invocable<_Self, _Range>
   886	      friend constexpr auto
   887	      operator|(_Range&& __r, _Self&& __self)
   888	      { return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
   889	
   890	    // Compose the adaptors __lhs and __rhs into a pipeline, returning
   891	    // another range adaptor closure object.
   892	    template<typename _Lhs, typename _Rhs>
   893	      requires derived_from<_Lhs, _RangeAdaptorClosure>
   894		&& derived_from<_Rhs, _RangeAdaptorClosure>
   895	      friend constexpr auto
   896	      operator|(_Lhs __lhs, _Rhs __rhs)
   897	      { return _Pipe<_Lhs, _Rhs>{std::move(__lhs), std::move(__rhs)}; }
   898	  };
   899	
   900	  // The base class of every range adaptor non-closure.
   901	  //
   902	  // The static data member _Derived::_S_arity must contain the total number of
   903	  // arguments that the adaptor takes, and the class _Derived must introduce
   904	  // _RangeAdaptor::operator() into the class scope via a using-declaration.
   905	  //
   906	  // The optional static data member _Derived::_S_has_simple_extra_args should
   907	  // be defined to true if the behavior of this adaptor is independent of the
   908	  // constness/value category of the extra arguments.  This data member could
   909	  // also be defined as a variable template parameterized by the types of the
   910	  // extra arguments.
   911	  template<typename _Derived>
   912	    struct _RangeAdaptor
   913	    {
   914	      // Partially apply the arguments __args to the range adaptor _Derived,
   915	      // returning a range adaptor closure object.
   916	      template<typename... _Args>
   917		requires __adaptor_partial_app_viable<_Derived, _Args...>
   918		constexpr auto
   919		operator()(_Args&&... __args) const
   920		{
   921		  return _Partial<_Derived, decay_t<_Args>...>{std::forward<_Args>(__args)...};
   922		}
   923	    };
   924	
   925	  // True if the range adaptor closure _Adaptor has a simple operator(), i.e.
   926	  // one that's not overloaded according to constness or value category of the
   927	  // _Adaptor object.
   928	  template<typename _Adaptor>
   929	    concept __closure_has_simple_call_op = _Adaptor::_S_has_simple_call_op;
   930	
   931	  // True if the behavior of the range adaptor non-closure _Adaptor is
   932	  // independent of the value category of its extra arguments _Args.
   933	  template<typename _Adaptor, typename... _Args>
   934	    concept __adaptor_has_simple_extra_args = _Adaptor::_S_has_simple_extra_args
   935	      || _Adaptor::template _S_has_simple_extra_args<_Args...>;
   936	
   937	  // A range adaptor closure that represents partial application of
   938	  // the range adaptor _Adaptor with arguments _Args.
   939	  template<typename _Adaptor, typename... _Args>
   940	    struct _Partial : _RangeAdaptorClosure
   941	    {
   942	      tuple<_Args...> _M_args;
   943	
   944	      constexpr
   945	      _Partial(_Args... __args)
   946		: _M_args(std::move(__args)...)
   947	      { }
   948	
   949	      // Invoke _Adaptor with arguments __r, _M_args... according to the
   950	      // value category of this _Partial object.
   951	      template<typename _Range>
   952		requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
   953		constexpr auto
   954		operator()(_Range&& __r) const &
   955		{
   956		  auto __forwarder = [&__r] (const auto&... __args) {
   957		    return _Adaptor{}(std::forward<_Range>(__r), __args...);
   958		  };
   959		  return std::apply(__forwarder, _M_args);
   960		}
   961	
   962	      template<typename _Range>
   963		requires __adaptor_invocable<_Adaptor, _Range, _Args...>
   964		constexpr auto
   965		operator()(_Range&& __r) &&
   966		{
   967		  auto __forwarder = [&__r] (auto&... __args) {
   968		    return _Adaptor{}(std::forward<_Range>(__r), std::move(__args)...);
   969		  };
   970		  return std::apply(__forwarder, _M_args);
   971		}
   972	
   973	      template<typename _Range>
   974		constexpr auto
   975		operator()(_Range&& __r) const && = delete;
   976	    };
   977	
   978	  // A lightweight specialization of the above primary template for
   979	  // the common case where _Adaptor accepts a single extra argument.
   980	  template<typename _Adaptor, typename _Arg>
   981	    struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
   982	    {
   983	      _Arg _M_arg;
   984	
   985	      constexpr
   986	      _Partial(_Arg __arg)
   987		: _M_arg(std::move(__arg))
   988	      { }
   989	
   990	      template<typename _Range>
   991		requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
   992		constexpr auto
   993		operator()(_Range&& __r) const &
   994		{ return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
   995	
   996	      template<typename _Range>
   997		requires __adaptor_invocable<_Adaptor, _Range, _Arg>
   998		constexpr auto
   999		operator()(_Range&& __r) &&
  1000		{ return _Adaptor{}(std::forward<_Range>(__r), std::move(_M_arg)); }
  1001	
  1002	      template<typename _Range>
  1003		constexpr auto
  1004		operator()(_Range&& __r) const && = delete;
  1005	    };
  1006	
  1007	  // Partial specialization of the primary template for the case where the extra
  1008	  // arguments of the adaptor can always be safely and efficiently forwarded by
  1009	  // const reference.  This lets us get away with a single operator() overload,
  1010	  // which makes overload resolution failure diagnostics more concise.
  1011	  template<typename _Adaptor, typename... _Args>
  1012	    requires __adaptor_has_simple_extra_args<_Adaptor, _Args...>
  1013	      && (is_trivially_copyable_v<_Args> && ...)
  1014	    struct _Partial<_Adaptor, _Args...> : _RangeAdaptorClosure
  1015	    {
  1016	      tuple<_Args...> _M_args;
  1017	
  1018	      constexpr
  1019	      _Partial(_Args... __args)
  1020		: _M_args(std::move(__args)...)
  1021	      { }
  1022	
  1023	      // Invoke _Adaptor with arguments __r, const _M_args&... regardless
  1024	      // of the value category of this _Partial object.
  1025	      template<typename _Range>
  1026		requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
  1027		constexpr auto
  1028		operator()(_Range&& __r) const
  1029		{
  1030		  auto __forwarder = [&__r] (const auto&... __args) {
  1031		    return _Adaptor{}(std::forward<_Range>(__r), __args...);
  1032		  };
  1033		  return std::apply(__forwarder, _M_args);
  1034		}
  1035	
  1036	      static constexpr bool _S_has_simple_call_op = true;
  1037	    };
  1038	
  1039	  // A lightweight specialization of the above template for the common case
  1040	  // where _Adaptor accepts a single extra argument.
  1041	  template<typename _Adaptor, typename _Arg>
  1042	    requires __adaptor_has_simple_extra_args<_Adaptor, _Arg>
  1043	      && is_trivially_copyable_v<_Arg>
  1044	    struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
  1045	    {
  1046	      _Arg _M_arg;
  1047	
  1048	      constexpr
  1049	      _Partial(_Arg __arg)
  1050		: _M_arg(std::move(__arg))
  1051	      { }
  1052	
  1053	      template<typename _Range>
  1054		requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
  1055		constexpr auto
  1056		operator()(_Range&& __r) const
  1057		{ return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
  1058	
  1059	      static constexpr bool _S_has_simple_call_op = true;
  1060	    };
  1061	
  1062	  template<typename _Lhs, typename _Rhs, typename _Range>
  1063	    concept __pipe_invocable
  1064	      = requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
  1065	
  1066	  // A range adaptor closure that represents composition of the range
  1067	  // adaptor closures _Lhs and _Rhs.
  1068	  template<typename _Lhs, typename _Rhs>
  1069	    struct _Pipe : _RangeAdaptorClosure
  1070	    {
  1071	      [[no_unique_address]] _Lhs _M_lhs;
  1072	      [[no_unique_address]] _Rhs _M_rhs;
  1073	
  1074	      constexpr
  1075	      _Pipe(_Lhs __lhs, _Rhs __rhs)
  1076		: _M_lhs(std::move(__lhs)), _M_rhs(std::move(__rhs))
  1077	      { }
  1078	
  1079	      // Invoke _M_rhs(_M_lhs(__r)) according to the value category of this
  1080	      // range adaptor closure object.
  1081	      template<typename _Range>
  1082		requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
  1083		constexpr auto
  1084		operator()(_Range&& __r) const &
  1085		{ return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
  1086	
  1087	      template<typename _Range>
  1088		requires __pipe_invocable<_Lhs, _Rhs, _Range>
  1089		constexpr auto
  1090		operator()(_Range&& __r) &&
  1091		{ return std::move(_M_rhs)(std::move(_M_lhs)(std::forward<_Range>(__r))); }
  1092	
  1093	      template<typename _Range>
  1094		constexpr auto
  1095		operator()(_Range&& __r) const && = delete;
  1096	    };
  1097	
  1098	  // A partial specialization of the above primary template for the case where
  1099	  // both adaptor operands have a simple operator().  This in turn lets us
  1100	  // implement composition using a single simple operator(), which makes
  1101	  // overload resolution failure diagnostics more concise.
  1102	  template<typename _Lhs, typename _Rhs>
  1103	    requires __closure_has_simple_call_op<_Lhs>
  1104	      && __closure_has_simple_call_op<_Rhs>
  1105	    struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure
  1106	    {
  1107	      [[no_unique_address]] _Lhs _M_lhs;
  1108	      [[no_unique_address]] _Rhs _M_rhs;
  1109	
  1110	      constexpr
  1111	      _Pipe(_Lhs __lhs, _Rhs __rhs)
  1112		: _M_lhs(std::move(__lhs)), _M_rhs(std::move(__rhs))
  1113	      { }
  1114	
  1115	      template<typename _Range>
  1116		requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
  1117		constexpr auto
  1118		operator()(_Range&& __r) const
  1119		{ return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
  1120	
  1121	      static constexpr bool _S_has_simple_call_op = true;
  1122	    };
  1123	} // namespace views::__adaptor
  1124	
  1125	#if __cplusplus > 202002L
  1126	  template<typename _Derived>
  1127	    requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
  1128	    class range_adaptor_closure
  1129	    : public views::__adaptor::_RangeAdaptorClosure
  1130	    { };
  1131	#endif
  1132	
  1133	  template<range _Range> requires is_object_v<_Range>
  1134	    class ref_view : public view_interface<ref_view<_Range>>
  1135	    {
  1136	    private:
  1137	      _Range* _M_r;
  1138	
  1139	      static void _S_fun(_Range&); // not defined
  1140	      static void _S_fun(_Range&&) = delete;
  1141	
  1142	    public:
  1143	      template<__detail::__different_from<ref_view> _Tp>
  1144		requires convertible_to<_Tp, _Range&>
  1145		  && requires { _S_fun(declval<_Tp>()); }
  1146		constexpr
  1147		ref_view(_Tp&& __t)
  1148		noexcept(noexcept(static_cast<_Range&>(std::declval<_Tp>())))
  1149		  : _M_r(std::__addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))
  1150		{ }
  1151	
  1152	      constexpr _Range&
  1153	      base() const
  1154	      { return *_M_r; }
  1155	
  1156	      constexpr iterator_t<_Range>
  1157	      begin() const
  1158	      { return ranges::begin(*_M_r); }
  1159	
  1160	      constexpr sentinel_t<_Range>
  1161	      end() const
  1162	      { return ranges::end(*_M_r); }
  1163	
  1164	      constexpr bool
  1165	      empty() const requires requires { ranges::empty(*_M_r); }
  1166	      { return ranges::empty(*_M_r); }
  1167	
  1168	      constexpr auto
  1169	      size() const requires sized_range<_Range>
  1170	      { return ranges::size(*_M_r); }
  1171	
  1172	      constexpr auto
  1173	      data() const requires contiguous_range<_Range>
  1174	      { return ranges::data(*_M_r); }
  1175	    };
  1176	
  1177	  template<typename _Range>
  1178	    ref_view(_Range&) -> ref_view<_Range>;
  1179	
  1180	  template<typename _Tp>
  1181	    inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
  1182	
  1183	  template<range _Range>
  1184	    requires movable<_Range>
  1185	      && (!__detail::__is_initializer_list<remove_cv_t<_Range>>)
  1186	    class owning_view : public view_interface<owning_view<_Range>>
  1187	    {
  1188	    private:
  1189	      _Range _M_r = _Range();
  1190	
  1191	    public:
  1192	      owning_view() requires default_initializable<_Range> = default;
  1193	
  1194	      constexpr
  1195	      owning_view(_Range&& __t)
  1196	      noexcept(is_nothrow_move_constructible_v<_Range>)
  1197		: _M_r(std::move(__t))
  1198	      { }
  1199	
  1200	      owning_view(owning_view&&) = default;
  1201	      owning_view& operator=(owning_view&&) = default;
  1202	
  1203	      constexpr _Range&
  1204	      base() & noexcept
  1205	      { return _M_r; }
  1206	
  1207	      constexpr const _Range&
  1208	      base() const& noexcept
  1209	      { return _M_r; }
  1210	
  1211	      constexpr _Range&&
  1212	      base() && noexcept
  1213	      { return std::move(_M_r); }
  1214	
  1215	      constexpr const _Range&&
  1216	      base() const&& noexcept
  1217	      { return std::move(_M_r); }
  1218	
  1219	      constexpr iterator_t<_Range>
  1220	      begin()
  1221	      { return ranges::begin(_M_r); }
  1222	
  1223	      constexpr sentinel_t<_Range>
  1224	      end()
  1225	      { return ranges::end(_M_r); }
  1226	
  1227	      constexpr auto
  1228	      begin() const requires range<const _Range>
  1229	      { return ranges::begin(_M_r); }
  1230	
  1231	      constexpr auto
  1232	      end() const requires range<const _Range>
  1233	      { return ranges::end(_M_r); }
  1234	
  1235	      constexpr bool
  1236	      empty() requires requires { ranges::empty(_M_r); }
  1237	      { return ranges::empty(_M_r); }
  1238	
  1239	      constexpr bool
  1240	      empty() const requires requires { ranges::empty(_M_r); }
  1241	      { return ranges::empty(_M_r); }
  1242	
  1243	      constexpr auto
  1244	      size() requires sized_range<_Range>
  1245	      { return ranges::size(_M_r); }
  1246	
  1247	      constexpr auto
  1248	      size() const requires sized_range<const _Range>
  1249	      { return ranges::size(_M_r); }
  1250	
  1251	      constexpr auto
  1252	      data() requires contiguous_range<_Range>
  1253	      { return ranges::data(_M_r); }
  1254	
  1255	      constexpr auto
  1256	      data() const requires contiguous_range<const _Range>
  1257	      { return ranges::data(_M_r); }
  1258	    };
  1259	
  1260	  template<typename _Tp>
  1261	    inline constexpr bool enable_borrowed_range<owning_view<_Tp>>
  1262	      = enable_borrowed_range<_Tp>;
  1263	
  1264	  namespace views
  1265	  {
  1266	    namespace __detail
  1267	    {
  1268	      template<typename _Range>
  1269		concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };
  1270	
  1271	      template<typename _Range>
  1272		concept __can_owning_view = requires { owning_view{std::declval<_Range>()}; };
  1273	    } // namespace __detail
  1274	
  1275	    struct _All : __adaptor::_RangeAdaptorClosure
  1276	    {
  1277	      template<typename _Range>
  1278		static constexpr bool
  1279		_S_noexcept()
  1280		{
  1281		  if constexpr (view<decay_t<_Range>>)
  1282		    return is_nothrow_constructible_v<decay_t<_Range>, _Range>;
  1283		  else if constexpr (__detail::__can_ref_view<_Range>)
  1284		    return true;
  1285		  else
  1286		    return noexcept(owning_view{std::declval<_Range>()});
  1287		}
  1288	
  1289	      template<viewable_range _Range>
  1290		requires view<decay_t<_Range>>
  1291		  || __detail::__can_ref_view<_Range>
  1292		  || __detail::__can_owning_view<_Range>
  1293		constexpr auto
  1294		operator() [[nodiscard]] (_Range&& __r) const
  1295		noexcept(_S_noexcept<_Range>())
  1296		{
  1297		  if constexpr (view<decay_t<_Range>>)
  1298		    return std::forward<_Range>(__r);
  1299		  else if constexpr (__detail::__can_ref_view<_Range>)
  1300		    return ref_view{std::forward<_Range>(__r)};
  1301		  else
  1302		    return owning_view{std::forward<_Range>(__r)};
  1303		}
  1304	
  1305	      static constexpr bool _S_has_simple_call_op = true;
  1306	    };
  1307	
  1308	    inline constexpr _All all;
  1309	
  1310	    template<viewable_range _Range>
  1311	      using all_t = decltype(all(std::declval<_Range>()));
  1312	  } // namespace views
  1313	
  1314	  namespace __detail
  1315	  {
  1316	    template<typename _Tp>
  1317	      struct __non_propagating_cache
  1318	      {
  1319		// When _Tp is not an object type (e.g. is a reference type), we make
  1320		// __non_propagating_cache<_Tp> empty rather than ill-formed so that
  1321		// users can easily conditionally declare data members with this type
  1322		// (such as join_view::_M_inner).
  1323	      };
  1324	
  1325	    template<typename _Tp>
  1326	      requires is_object_v<_Tp>
  1327	      struct __non_propagating_cache<_Tp>
  1328	      : protected _Optional_base<_Tp>
  1329	      {
  1330		__non_propagating_cache() = default;
  1331	
  1332		constexpr
  1333		__non_propagating_cache(const __non_propagating_cache&) noexcept
  1334		{ }
  1335	
  1336		constexpr
  1337		__non_propagating_cache(__non_propagating_cache&& __other) noexcept
  1338		{ __other._M_reset(); }
  1339	
  1340		constexpr __non_propagating_cache&
  1341		operator=(const __non_propagating_cache& __other) noexcept
  1342		{
  1343		  if (std::__addressof(__other) != this)
  1344		    this->_M_reset();
  1345		  return *this;
  1346		}
  1347	
  1348		constexpr __non_propagating_cache&
  1349		operator=(__non_propagating_cache&& __other) noexcept
  1350		{
  1351		  this->_M_reset();
  1352		  __other._M_reset();
  1353		  return *this;
  1354		}
  1355	
  1356		constexpr __non_propagating_cache&
  1357		operator=(_Tp __val)
  1358		{
  1359		  this->_M_reset();
  1360		  this->_M_payload._M_construct(std::move(__val));
  1361		  return *this;
  1362		}
  1363	
  1364		constexpr explicit
  1365		operator bool() const noexcept
  1366		{ return this->_M_is_engaged(); }
  1367	
  1368		constexpr _Tp&
  1369		operator*() noexcept
  1370		{ return this->_M_get(); }
  1371	
  1372		constexpr const _Tp&
  1373		operator*() const noexcept
  1374		{ return this->_M_get(); }
  1375	
  1376		template<typename _Iter>
  1377		  constexpr _Tp&
  1378		  _M_emplace_deref(const _Iter& __i)
  1379		  {
  1380		    this->_M_reset();
  1381		    auto __f = [] (auto& __x) { return *__x; };
  1382		    this->_M_payload._M_apply(_Optional_func{__f}, __i);
  1383		    return this->_M_get();
  1384		  }
  1385	      };
  1386	
  1387	    template<range _Range>
  1388	      struct _CachedPosition
  1389	      {
  1390		constexpr bool
  1391		_M_has_value() const
  1392		{ return false; }
  1393	
  1394		constexpr iterator_t<_Range>
  1395		_M_get(const _Range&) const
  1396		{
  1397		  __glibcxx_assert(false);
  1398		  __builtin_unreachable();
  1399		}
  1400	
  1401		constexpr void
  1402		_M_set(const _Range&, const iterator_t<_Range>&) const
  1403		{ }
  1404	      };
  1405	
  1406	    template<forward_range _Range>
  1407	      struct _CachedPosition<_Range>
  1408		: protected __non_propagating_cache<iterator_t<_Range>>
  1409	      {
  1410		constexpr bool
  1411		_M_has_value() const
  1412		{ return this->_M_is_engaged(); }
  1413	
  1414		constexpr iterator_t<_Range>
  1415		_M_get(const _Range&) const
  1416		{
  1417		  __glibcxx_assert(_M_has_value());
  1418		  return **this;
  1419		}
  1420	
  1421		constexpr void
  1422		_M_set(const _Range&, const iterator_t<_Range>& __it)
  1423		{
  1424		  __glibcxx_assert(!_M_has_value());
  1425		  std::construct_at(std::__addressof(this->_M_payload._M_payload),
  1426				    in_place, __it);
  1427		  this->_M_payload._M_engaged = true;
  1428		}
  1429	      };
  1430	
  1431	    template<random_access_range _Range>
  1432	      requires (sizeof(range_difference_t<_Range>)
  1433			<= sizeof(iterator_t<_Range>))
  1434	      struct _CachedPosition<_Range>
  1435	      {
  1436	      private:
  1437		range_difference_t<_Range> _M_offset = -1;
  1438	
  1439	      public:
  1440		_CachedPosition() = default;
  1441	
  1442		constexpr
  1443		_CachedPosition(const _CachedPosition&) = default;
  1444	
  1445		constexpr
  1446		_CachedPosition(_CachedPosition&& __other) noexcept
  1447		{ *this = std::move(__other); }
  1448	
  1449		constexpr _CachedPosition&
  1450		operator=(const _CachedPosition&) = default;
  1451	
  1452		constexpr _CachedPosition&
  1453		operator=(_CachedPosition&& __other) noexcept
  1454		{
  1455		  // Propagate the cached offset, but invalidate the source.
  1456		  _M_offset = __other._M_offset;
  1457		  __other._M_offset = -1;
  1458		  return *this;
  1459		}
  1460	
  1461		constexpr bool
  1462		_M_has_value() const
  1463		{ return _M_offset >= 0; }
  1464	
  1465		constexpr iterator_t<_Range>
  1466		_M_get(_Range& __r) const
  1467		{
  1468		  __glibcxx_assert(_M_has_value());
  1469		  return ranges::begin(__r) + _M_offset;
  1470		}
  1471	
  1472		constexpr void
  1473		_M_set(_Range& __r, const iterator_t<_Range>& __it)
  1474		{
  1475		  __glibcxx_assert(!_M_has_value());
  1476		  _M_offset = __it - ranges::begin(__r);
  1477		}
  1478	      };
  1479	  } // namespace __detail
  1480	
  1481	  namespace __detail
  1482	  {
  1483	    template<typename _Base>
  1484	      struct __filter_view_iter_cat
  1485	      { };
  1486	
  1487	    template<forward_range _Base>
  1488	      struct __filter_view_iter_cat<_Base>
  1489	      {
  1490	      private:
  1491		static auto
  1492		_S_iter_cat()
  1493		{
  1494		  using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
  1495		  if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
  1496		    return bidirectional_iterator_tag{};
  1497		  else if constexpr (derived_from<_Cat, forward_iterator_tag>)
  1498		    return forward_iterator_tag{};
  1499		  else
  1500		    return _Cat{};
  1501		}
  1502	      public:
  1503		using iterator_category = decltype(_S_iter_cat());
  1504	      };
  1505	  } // namespace __detail
  1506	
  1507	  template<input_range _Vp,
  1508		   indirect_unary_predicate<iterator_t<_Vp>> _Pred>
  1509	    requires view<_Vp> && is_object_v<_Pred>
  1510	    class filter_view : public view_interface<filter_view<_Vp, _Pred>>
  1511	    {
  1512	    private:
  1513	      struct _Sentinel;
  1514	
  1515	      struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
  1516	      {
  1517	      private:
  1518		static constexpr auto
  1519		_S_iter_concept()
  1520		{
  1521		  if constexpr (bidirectional_range<_Vp>)
  1522		    return bidirectional_iterator_tag{};
  1523		  else if constexpr (forward_range<_Vp>)
  1524		    return forward_iterator_tag{};
  1525		  else
  1526		    return input_iterator_tag{};
  1527		}
  1528	
  1529		friend filter_view;
  1530	
  1531		using _Vp_iter = iterator_t<_Vp>;
  1532	
  1533		_Vp_iter _M_current = _Vp_iter();
  1534		filter_view* _M_parent = nullptr;
  1535	
  1536	      public:
  1537		using iterator_concept = decltype(_S_iter_concept());
  1538		// iterator_category defined in __filter_view_iter_cat
  1539		using value_type = range_value_t<_Vp>;
  1540		using difference_type = range_difference_t<_Vp>;
  1541	
  1542		_Iterator() requires default_initializable<_Vp_iter> = default;
  1543	
  1544		constexpr
  1545		_Iterator(filter_view* __parent, _Vp_iter __current)
  1546		  : _M_current(std::move(__current)),
  1547		    _M_parent(__parent)
  1548		{ }
  1549	
  1550		constexpr const _Vp_iter&
  1551		base() const & noexcept
  1552		{ return _M_current; }
  1553	
  1554		constexpr _Vp_iter
  1555		base() &&
  1556		{ return std::move(_M_current); }
  1557	
  1558		constexpr range_reference_t<_Vp>
  1559		operator*() const
  1560		{ return *_M_current; }
  1561	
  1562		constexpr _Vp_iter
  1563		operator->() const
  1564		  requires __detail::__has_arrow<_Vp_iter>
  1565		    && copyable<_Vp_iter>
  1566		{ return _M_current; }
  1567	
  1568		constexpr _Iterator&
  1569		operator++()
  1570		{
  1571		  _M_current = ranges::find_if(std::move(++_M_current),
  1572					       ranges::end(_M_parent->_M_base),
  1573					       std::ref(*_M_parent->_M_pred));
  1574		  return *this;
  1575		}
  1576	
  1577		constexpr void
  1578		operator++(int)
  1579		{ ++*this; }
  1580	
  1581		constexpr _Iterator
  1582		operator++(int) requires forward_range<_Vp>
  1583		{
  1584		  auto __tmp = *this;
  1585		  ++*this;
  1586		  return __tmp;
  1587		}
  1588	
  1589		constexpr _Iterator&
  1590		operator--() requires bidirectional_range<_Vp>
  1591		{
  1592		  do
  1593		    --_M_current;
  1594		  while (!std::__invoke(*_M_parent->_M_pred, *_M_current));
  1595		  return *this;
  1596		}
  1597	
  1598		constexpr _Iterator
  1599		operator--(int) requires bidirectional_range<_Vp>
  1600		{
  1601		  auto __tmp = *this;
  1602		  --*this;
  1603		  return __tmp;
  1604		}
  1605	
  1606		friend constexpr bool
  1607		operator==(const _Iterator& __x, const _Iterator& __y)
  1608		  requires equality_comparable<_Vp_iter>
  1609		{ return __x._M_current == __y._M_current; }
  1610	
  1611		friend constexpr range_rvalue_reference_t<_Vp>
  1612		iter_move(const _Iterator& __i)
  1613		  noexcept(noexcept(ranges::iter_move(__i._M_current)))
  1614		{ return ranges::iter_move(__i._M_current); }
  1615	
  1616		friend constexpr void
  1617		iter_swap(const _Iterator& __x, const _Iterator& __y)
  1618		  noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
  1619		  requires indirectly_swappable<_Vp_iter>
  1620		{ ranges::iter_swap(__x._M_current, __y._M_current); }
  1621	      };
  1622	
  1623	      struct _Sentinel
  1624	      {
  1625	      private:
  1626		sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
  1627	
  1628		constexpr bool
  1629		__equal(const _Iterator& __i) const
  1630		{ return __i._M_current == _M_end; }
  1631	
  1632	      public:
  1633		_Sentinel() = default;
  1634	
  1635		constexpr explicit
  1636		_Sentinel(filter_view* __parent)
  1637		  : _M_end(ranges::end(__parent->_M_base))
  1638		{ }
  1639	
  1640		constexpr sentinel_t<_Vp>
  1641		base() const
  1642		{ return _M_end; }
  1643	
  1644		friend constexpr bool
  1645		operator==(const _Iterator& __x, const _Sentinel& __y)
  1646		{ return __y.__equal(__x); }
  1647	      };
  1648	
  1649	      _Vp _M_base = _Vp();
  1650	      [[no_unique_address]] __detail::__box<_Pred> _M_pred;
  1651	      [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
  1652	
  1653	    public:
  1654	      filter_view() requires (default_initializable<_Vp>
  1655				      && default_initializable<_Pred>)
  1656		= default;
  1657	
  1658	      constexpr
  1659	      filter_view(_Vp __base, _Pred __pred)
  1660		: _M_base(std::move(__base)), _M_pred(std::move(__pred))
  1661	      { }
  1662	
  1663	      constexpr _Vp
  1664	      base() const& requires copy_constructible<_Vp>
  1665	      { return _M_base; }
  1666	
  1667	      constexpr _Vp
  1668	      base() &&
  1669	      { return std::move(_M_base); }
  1670	
  1671	      constexpr const _Pred&
  1672	      pred() const
  1673	      { return *_M_pred; }
  1674	
  1675	      constexpr _Iterator
  1676	      begin()
  1677	      {
  1678		if (_M_cached_begin._M_has_value())
  1679		  return {this, _M_cached_begin._M_get(_M_base)};
  1680	
  1681		__glibcxx_assert(_M_pred.has_value());
  1682		auto __it = ranges::find_if(ranges::begin(_M_base),
  1683					    ranges::end(_M_base),
  1684					    std::ref(*_M_pred));
  1685		_M_cached_begin._M_set(_M_base, __it);
  1686		return {this, std::move(__it)};
  1687	      }
  1688	
  1689	      constexpr auto
  1690	      end()
  1691	      {
  1692		if constexpr (common_range<_Vp>)
  1693		  return _Iterator{this, ranges::end(_M_base)};
  1694		else
  1695		  return _Sentinel{this};
  1696	      }
  1697	    };
  1698	
  1699	  template<typename _Range, typename _Pred>
  1700	    filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
  1701	
  1702	  namespace views
  1703	  {
  1704	    namespace __detail
  1705	    {
  1706	      template<typename _Range, typename _Pred>
  1707		concept __can_filter_view
  1708		  = requires { filter_view(std::declval<_Range>(), std::declval<_Pred>()); };
  1709	    } // namespace __detail
  1710	
  1711	    struct _Filter : __adaptor::_RangeAdaptor<_Filter>
  1712	    {
  1713	      template<viewable_range _Range, typename _Pred>
  1714		requires __detail::__can_filter_view<_Range, _Pred>
  1715		constexpr auto
  1716		operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
  1717		{
  1718		  return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
  1719		}
  1720	
  1721	      using _RangeAdaptor<_Filter>::operator();
  1722	      static constexpr int _S_arity = 2;
  1723	      static constexpr bool _S_has_simple_extra_args = true;
  1724	    };
  1725	
  1726	    inline constexpr _Filter filter;
  1727	  } // namespace views
  1728	
  1729	  template<input_range _Vp, copy_constructible _Fp>
  1730	    requires view<_Vp> && is_object_v<_Fp>
  1731	      && regular_invocable<_Fp&, range_reference_t<_Vp>>
  1732	      && std::__detail::__can_reference<invoke_result_t<_Fp&,
  1733								range_reference_t<_Vp>>>
  1734	    class transform_view : public view_interface<transform_view<_Vp, _Fp>>
  1735	    {
  1736	    private:
  1737	      template<bool _Const>
  1738		using _Base = __detail::__maybe_const_t<_Const, _Vp>;
  1739	
  1740	      template<bool _Const>
  1741		struct __iter_cat
  1742		{ };
  1743	
  1744	      template<bool _Const>
  1745		requires forward_range<_Base<_Const>>
  1746		struct __iter_cat<_Const>
  1747		{
  1748		private:
  1749		  static auto
  1750		  _S_iter_cat()
  1751		  {
  1752		    using _Base = transform_view::_Base<_Const>;
  1753		    using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>;
  1754		    if constexpr (is_lvalue_reference_v<_Res>)
  1755		      {
  1756			using _Cat
  1757			  = typename iterator_traits<iterator_t<_Base>>::iterator_category;
  1758			if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
  1759			  return random_access_iterator_tag{};
  1760			else
  1761			  return _Cat{};
  1762		      }
  1763		    else
  1764		      return input_iterator_tag{};
  1765		  }
  1766		public:
  1767		  using iterator_category = decltype(_S_iter_cat());
  1768		};
  1769	
  1770	      template<bool _Const>
  1771		struct _Sentinel;
  1772	
  1773	      template<bool _Const>
  1774		struct _Iterator : __iter_cat<_Const>
  1775		{
  1776		private:
  1777		  using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
  1778		  using _Base = transform_view::_Base<_Const>;
  1779	
  1780		  static auto
  1781		  _S_iter_concept()
  1782		  {
  1783		    if constexpr (random_access_range<_Base>)
  1784		      return random_access_iterator_tag{};
  1785		    else if constexpr (bidirectional_range<_Base>)
  1786		      return bidirectional_iterator_tag{};
  1787		    else if constexpr (forward_range<_Base>)
  1788		      return forward_iterator_tag{};
  1789		    else
  1790		      return input_iterator_tag{};
  1791		  }
  1792	
  1793		  using _Base_iter = iterator_t<_Base>;
  1794	
  1795		  _Base_iter _M_current = _Base_iter();
  1796		  _Parent* _M_parent = nullptr;
  1797	
  1798		public:
  1799		  using iterator_concept = decltype(_S_iter_concept());
  1800		  // iterator_category defined in __transform_view_iter_cat
  1801		  using value_type
  1802		    = remove_cvref_t<invoke_result_t<_Fp&, range_reference_t<_Base>>>;
  1803		  using difference_type = range_difference_t<_Base>;
  1804	
  1805		  _Iterator() requires default_initializable<_Base_iter> = default;
  1806	
  1807		  constexpr
  1808		  _Iterator(_Parent* __parent, _Base_iter __current)
  1809		    : _M_current(std::move(__current)),
  1810		      _M_parent(__parent)
  1811		  { }
  1812	
  1813		  constexpr
  1814		  _Iterator(_Iterator<!_Const> __i)
  1815		    requires _Const
  1816		      && convertible_to<iterator_t<_Vp>, _Base_iter>
  1817		    : _M_current(std::move(__i._M_current)), _M_parent(__i._M_parent)
  1818		  { }
  1819	
  1820		  constexpr const _Base_iter&
  1821		  base() const & noexcept
  1822		  { return _M_current; }
  1823	
  1824		  constexpr _Base_iter
  1825		  base() &&
  1826		  { return std::move(_M_current); }
  1827	
  1828		  constexpr decltype(auto)
  1829		  operator*() const
  1830		    noexcept(noexcept(std::__invoke(*_M_parent->_M_fun, *_M_current)))
  1831		  { return std::__invoke(*_M_parent->_M_fun, *_M_current); }
  1832	
  1833		  constexpr _Iterator&
  1834		  operator++()
  1835		  {
  1836		    ++_M_current;
  1837		    return *this;
  1838		  }
  1839	
  1840		  constexpr void
  1841		  operator++(int)
  1842		  { ++_M_current; }
  1843	
  1844		  constexpr _Iterator
  1845		  operator++(int) requires forward_range<_Base>
  1846		  {
  1847		    auto __tmp = *this;
  1848		    ++*this;
  1849		    return __tmp;
  1850		  }
  1851	
  1852		  constexpr _Iterator&
  1853		  operator--() requires bidirectional_range<_Base>
  1854		  {
  1855		    --_M_current;
  1856		    return *this;
  1857		  }
  1858	
  1859		  constexpr _Iterator
  1860		  operator--(int) requires bidirectional_range<_Base>
  1861		  {
  1862		    auto __tmp = *this;
  1863		    --*this;
  1864		    return __tmp;
  1865		  }
  1866	
  1867		  constexpr _Iterator&
  1868		  operator+=(difference_type __n) requires random_access_range<_Base>
  1869		  {
  1870		    _M_current += __n;
  1871		    return *this;
  1872		  }
  1873	
  1874		  constexpr _Iterator&
  1875		  operator-=(difference_type __n) requires random_access_range<_Base>
  1876		  {
  1877		    _M_current -= __n;
  1878		    return *this;
  1879		  }
  1880	
  1881		  constexpr decltype(auto)
  1882		  operator[](difference_type __n) const
  1883		    requires random_access_range<_Base>
  1884		  { return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
  1885	
  1886		  friend constexpr bool
  1887		  operator==(const _Iterator& __x, const _Iterator& __y)
  1888		    requires equality_comparable<_Base_iter>
  1889		  { return __x._M_current == __y._M_current; }
  1890	
  1891		  friend constexpr bool
  1892		  operator<(const _Iterator& __x, const _Iterator& __y)
  1893		    requires random_access_range<_Base>
  1894		  { return __x._M_current < __y._M_current; }
  1895	
  1896		  friend constexpr bool
  1897		  operator>(const _Iterator& __x, const _Iterator& __y)
  1898		    requires random_access_range<_Base>
  1899		  { return __y < __x; }
  1900	
  1901		  friend constexpr bool
  1902		  operator<=(const _Iterator& __x, const _Iterator& __y)
  1903		    requires random_access_range<_Base>
  1904		  { return !(__y < __x); }
  1905	
  1906		  friend constexpr bool
  1907		  operator>=(const _Iterator& __x, const _Iterator& __y)
  1908		    requires random_access_range<_Base>
  1909		  { return !(__x < __y); }
  1910	
  1911	#ifdef __cpp_lib_three_way_comparison
  1912		  friend constexpr auto
  1913		  operator<=>(const _Iterator& __x, const _Iterator& __y)
  1914		    requires random_access_range<_Base>
  1915		      && three_way_comparable<_Base_iter>
  1916		  { return __x._M_current <=> __y._M_current; }
  1917	#endif
  1918	
  1919		  friend constexpr _Iterator
  1920		  operator+(_Iterator __i, difference_type __n)
  1921		    requires random_access_range<_Base>
  1922		  { return {__i._M_parent, __i._M_current + __n}; }
  1923	
  1924		  friend constexpr _Iterator
  1925		  operator+(difference_type __n, _Iterator __i)
  1926		    requires random_access_range<_Base>
  1927		  { return {__i._M_parent, __i._M_current + __n}; }
  1928	
  1929		  friend constexpr _Iterator
  1930		  operator-(_Iterator __i, difference_type __n)
  1931		    requires random_access_range<_Base>
  1932		  { return {__i._M_parent, __i._M_current - __n}; }
  1933	
  1934		  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  1935		  // 3483. transform_view::iterator's difference is overconstrained
  1936		  friend constexpr difference_type
  1937		  operator-(const _Iterator& __x, const _Iterator& __y)
  1938		    requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
  1939		  { return __x._M_current - __y._M_current; }
  1940	
  1941		  friend constexpr decltype(auto)
  1942		  iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
  1943		  {
  1944		    if constexpr (is_lvalue_reference_v<decltype(*__i)>)
  1945		      return std::move(*__i);
  1946		    else
  1947		      return *__i;
  1948		  }
  1949	
  1950		  friend _Iterator<!_Const>;
  1951		  template<bool> friend struct _Sentinel;
  1952		};
  1953	
  1954	      template<bool _Const>
  1955		struct _Sentinel
  1956		{
  1957		private:
  1958		  using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
  1959		  using _Base = transform_view::_Base<_Const>;
  1960	
  1961		  template<bool _Const2>
  1962		    constexpr auto
  1963		    __distance_from(const _Iterator<_Const2>& __i) const
  1964		    { return _M_end - __i._M_current; }
  1965	
  1966		  template<bool _Const2>
  1967		    constexpr bool
  1968		    __equal(const _Iterator<_Const2>& __i) const
  1969		    { return __i._M_current == _M_end; }
  1970	
  1971		  sentinel_t<_Base> _M_end = sentinel_t<_Base>();
  1972	
  1973		public:
  1974		  _Sentinel() = default;
  1975	
  1976		  constexpr explicit
  1977		  _Sentinel(sentinel_t<_Base> __end)
  1978		    : _M_end(__end)
  1979		  { }
  1980	
  1981		  constexpr
  1982		  _Sentinel(_Sentinel<!_Const> __i)
  1983		    requires _Const
  1984		      && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
  1985		    : _M_end(std::move(__i._M_end))
  1986		  { }
  1987	
  1988		  constexpr sentinel_t<_Base>
  1989		  base() const
  1990		  { return _M_end; }
  1991	
  1992		  template<bool _Const2>
  1993		    requires sentinel_for<sentinel_t<_Base>,
  1994			       iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
  1995		    friend constexpr bool
  1996		    operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
  1997		    { return __y.__equal(__x); }
  1998	
  1999		  template<bool _Const2,
  2000			   typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
  2001		    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
  2002		    friend constexpr range_difference_t<_Base2>
  2003		    operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
  2004		    { return -__y.__distance_from(__x); }
  2005	
  2006		  template<bool _Const2,
  2007			   typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
  2008		    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
  2009		    friend constexpr range_difference_t<_Base2>
  2010		    operator-(const _Sentinel& __y, const _Iterator<_Const2>& __x)
  2011		    { return __y.__distance_from(__x); }
  2012	
  2013		  friend _Sentinel<!_Const>;
  2014		};
  2015	
  2016	      _Vp _M_base = _Vp();
  2017	      [[no_unique_address]] __detail::__box<_Fp> _M_fun;
  2018	
  2019	    public:
  2020	      transform_view() requires (default_initializable<_Vp>
  2021					 && default_initializable<_Fp>)
  2022		= default;
  2023	
  2024	      constexpr
  2025	      transform_view(_Vp __base, _Fp __fun)
  2026		: _M_base(std::move(__base)), _M_fun(std::move(__fun))
  2027	      { }
  2028	
  2029	      constexpr _Vp
  2030	      base() const& requires copy_constructible<_Vp>
  2031	      { return _M_base ; }
  2032	
  2033	      constexpr _Vp
  2034	      base() &&
  2035	      { return std::move(_M_base); }
  2036	
  2037	      constexpr _Iterator<false>
  2038	      begin()
  2039	      { return _Iterator<false>{this, ranges::begin(_M_base)}; }
  2040	
  2041	      constexpr _Iterator<true>
  2042	      begin() const
  2043		requires range<const _Vp>
  2044		  && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
  2045	      { return _Iterator<true>{this, ranges::begin(_M_base)}; }
  2046	
  2047	      constexpr _Sentinel<false>
  2048	      end()
  2049	      { return _Sentinel<false>{ranges::end(_M_base)}; }
  2050	
  2051	      constexpr _Iterator<false>
  2052	      end() requires common_range<_Vp>
  2053	      { return _Iterator<false>{this, ranges::end(_M_base)}; }
  2054	
  2055	      constexpr _Sentinel<true>
  2056	      end() const
  2057		requires range<const _Vp>
  2058		  && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
  2059	      { return _Sentinel<true>{ranges::end(_M_base)}; }
  2060	
  2061	      constexpr _Iterator<true>
  2062	      end() const
  2063		requires common_range<const _Vp>
  2064		  && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
  2065	      { return _Iterator<true>{this, ranges::end(_M_base)}; }
  2066	
  2067	      constexpr auto
  2068	      size() requires sized_range<_Vp>
  2069	      { return ranges::size(_M_base); }
  2070	
  2071	      constexpr auto
  2072	      size() const requires sized_range<const _Vp>
  2073	      { return ranges::size(_M_base); }
  2074	    };
  2075	
  2076	  template<typename _Range, typename _Fp>
  2077	    transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
  2078	
  2079	  namespace views
  2080	  {
  2081	    namespace __detail
  2082	    {
  2083	      template<typename _Range, typename _Fp>
  2084		concept __can_transform_view
  2085		  = requires { transform_view(std::declval<_Range>(), std::declval<_Fp>()); };
  2086	    } // namespace __detail
  2087	
  2088	    struct _Transform : __adaptor::_RangeAdaptor<_Transform>
  2089	    {
  2090	      template<viewable_range _Range, typename _Fp>
  2091		requires __detail::__can_transform_view<_Range, _Fp>
  2092		constexpr auto
  2093		operator() [[nodiscard]] (_Range&& __r, _Fp&& __f) const
  2094		{
  2095		  return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
  2096		}
  2097	
  2098	      using _RangeAdaptor<_Transform>::operator();
  2099	      static constexpr int _S_arity = 2;
  2100	      static constexpr bool _S_has_simple_extra_args = true;
  2101	    };
  2102	
  2103	    inline constexpr _Transform transform;
  2104	  } // namespace views
  2105	
  2106	  template<view _Vp>
  2107	    class take_view : public view_interface<take_view<_Vp>>
  2108	    {
  2109	    private:
  2110	      template<bool _Const>
  2111		using _CI = counted_iterator<
  2112		  iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
  2113	
  2114	      template<bool _Const>
  2115		struct _Sentinel
  2116		{
  2117		private:
  2118		  using _Base = __detail::__maybe_const_t<_Const, _Vp>;
  2119		  sentinel_t<_Base> _M_end = sentinel_t<_Base>();
  2120	
  2121		public:
  2122		  _Sentinel() = default;
  2123	
  2124		  constexpr explicit
  2125		  _Sentinel(sentinel_t<_Base> __end)
  2126		    : _M_end(__end)
  2127		  { }
  2128	
  2129		  constexpr
  2130		  _Sentinel(_Sentinel<!_Const> __s)
  2131		    requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
  2132		    : _M_end(std::move(__s._M_end))
  2133		  { }
  2134	
  2135		  constexpr sentinel_t<_Base>
  2136		  base() const
  2137		  { return _M_end; }
  2138	
  2139		  friend constexpr bool
  2140		  operator==(const _CI<_Const>& __y, const _Sentinel& __x)
  2141		  { return __y.count() == 0 || __y.base() == __x._M_end; }
  2142	
  2143		  template<bool _OtherConst = !_Const,
  2144			   typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
  2145		    requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
  2146		  friend constexpr bool
  2147		  operator==(const _CI<_OtherConst>& __y, const _Sentinel& __x)
  2148		  { return __y.count() == 0 || __y.base() == __x._M_end; }
  2149	
  2150		  friend _Sentinel<!_Const>;
  2151		};
  2152	
  2153	      _Vp _M_base = _Vp();
  2154	      range_difference_t<_Vp> _M_count = 0;
  2155	
  2156	    public:
  2157	      take_view() requires default_initializable<_Vp> = default;
  2158	
  2159	      constexpr
  2160	      take_view(_Vp __base, range_difference_t<_Vp> __count)
  2161		: _M_base(std::move(__base)), _M_count(std::move(__count))
  2162	      { }
  2163	
  2164	      constexpr _Vp
  2165	      base() const& requires copy_constructible<_Vp>
  2166	      { return _M_base; }
  2167	
  2168	      constexpr _Vp
  2169	      base() &&
  2170	      { return std::move(_M_base); }
  2171	
  2172	      constexpr auto
  2173	      begin() requires (!__detail::__simple_view<_Vp>)
  2174	      {
  2175		if constexpr (sized_range<_Vp>)
  2176		  {
  2177		    if constexpr (random_access_range<_Vp>)
  2178		      return ranges::begin(_M_base);
  2179		    else
  2180		      {
  2181			auto __sz = size();
  2182			return counted_iterator(ranges::begin(_M_base), __sz);
  2183		      }
  2184		  }
  2185		else
  2186		  return counted_iterator(ranges::begin(_M_base), _M_count);
  2187	      }
  2188	
  2189	      constexpr auto
  2190	      begin() const requires range<const _Vp>
  2191	      {
  2192		if constexpr (sized_range<const _Vp>)
  2193		  {
  2194		    if constexpr (random_access_range<const _Vp>)
  2195		      return ranges::begin(_M_base);
  2196		    else
  2197		      {
  2198			auto __sz = size();
  2199			return counted_iterator(ranges::begin(_M_base), __sz);
  2200		      }
  2201		  }
  2202		else
  2203		  return counted_iterator(ranges::begin(_M_base), _M_count);
  2204	      }
  2205	
  2206	      constexpr auto
  2207	      end() requires (!__detail::__simple_view<_Vp>)
  2208	      {
  2209		if constexpr (sized_range<_Vp>)
  2210		  {
  2211		    if constexpr (random_access_range<_Vp>)
  2212		      return ranges::begin(_M_base) + size();
  2213		    else
  2214		      return default_sentinel;
  2215		  }
  2216		else
  2217		  return _Sentinel<false>{ranges::end(_M_base)};
  2218	      }
  2219	
  2220	      constexpr auto
  2221	      end() const requires range<const _Vp>
  2222	      {
  2223		if constexpr (sized_range<const _Vp>)
  2224		  {
  2225		    if constexpr (random_access_range<const _Vp>)
  2226		      return ranges::begin(_M_base) + size();
  2227		    else
  2228		      return default_sentinel;
  2229		  }
  2230		else
  2231		  return _Sentinel<true>{ranges::end(_M_base)};
  2232	      }
  2233	
  2234	      constexpr auto
  2235	      size() requires sized_range<_Vp>
  2236	      {
  2237		auto __n = ranges::size(_M_base);
  2238		return std::min(__n, static_cast<decltype(__n)>(_M_count));
  2239	      }
  2240	
  2241	      constexpr auto
  2242	      size() const requires sized_range<const _Vp>
  2243	      {
  2244		auto __n = ranges::size(_M_base);
  2245		return std::min(__n, static_cast<decltype(__n)>(_M_count));
  2246	      }
  2247	    };
  2248	
  2249	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  2250	  // 3447. Deduction guides for take_view and drop_view have different
  2251	  // constraints
  2252	  template<typename _Range>
  2253	    take_view(_Range&&, range_difference_t<_Range>)
  2254	      -> take_view<views::all_t<_Range>>;
  2255	
  2256	  template<typename _Tp>
  2257	    inline constexpr bool enable_borrowed_range<take_view<_Tp>>
  2258	      = enable_borrowed_range<_Tp>;
  2259	
  2260	  namespace views
  2261	  {
  2262	    namespace __detail
  2263	    {
  2264	      template<typename _Range>
  2265		inline constexpr bool __is_empty_view = false;
  2266	
  2267	      template<typename _Tp>
  2268		inline constexpr bool __is_empty_view<empty_view<_Tp>> = true;
  2269	
  2270	      template<typename _Range>
  2271		inline constexpr bool __is_basic_string_view = false;
  2272	
  2273	      template<typename _CharT, typename _Traits>
  2274		inline constexpr bool __is_basic_string_view<basic_string_view<_CharT, _Traits>>
  2275		  = true;
  2276	
  2277	      template<typename _Range>
  2278		inline constexpr bool __is_subrange = false;
  2279	
  2280	      template<typename _Iter, typename _Sent, subrange_kind _Kind>
  2281		inline constexpr bool __is_subrange<subrange<_Iter, _Sent, _Kind>> = true;
  2282	
  2283	      template<typename _Range>
  2284		inline constexpr bool __is_iota_view = false;
  2285	
  2286	      template<typename _Winc, typename _Bound>
  2287		inline constexpr bool __is_iota_view<iota_view<_Winc, _Bound>> = true;
  2288	
  2289	      template<typename _Range>
  2290		inline constexpr bool __is_repeat_view = false;
  2291	
  2292	      template<typename _Range>
  2293		constexpr auto
  2294		__take_of_repeat_view(_Range&&, range_difference_t<_Range>); // defined later
  2295	
  2296	      template<typename _Range, typename _Dp>
  2297		concept __can_take_view
  2298		  = requires { take_view(std::declval<_Range>(), std::declval<_Dp>()); };
  2299	    } // namespace __detail
  2300	
  2301	    struct _Take : __adaptor::_RangeAdaptor<_Take>
  2302	    {
  2303	      template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
  2304		requires __detail::__can_take_view<_Range, _Dp>
  2305		constexpr auto
  2306		operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
  2307		{
  2308		  using _Tp = remove_cvref_t<_Range>;
  2309		  if constexpr (__detail::__is_empty_view<_Tp>)
  2310		    return _Tp();
  2311		  else if constexpr (random_access_range<_Tp>
  2312				     && sized_range<_Tp>
  2313				     && (std::__detail::__is_span<_Tp>
  2314					 || __detail::__is_basic_string_view<_Tp>
  2315					 || __detail::__is_subrange<_Tp>
  2316					 || __detail::__is_iota_view<_Tp>))
  2317		    {
  2318		      __n = std::min<_Dp>(ranges::distance(__r), __n);
  2319		      auto __begin = ranges::begin(__r);
  2320		      auto __end = __begin + __n;
  2321		      if constexpr (std::__detail::__is_span<_Tp>)
  2322			return span<typename _Tp::element_type>(__begin, __end);
  2323		      else if constexpr (__detail::__is_basic_string_view<_Tp>)
  2324			return _Tp(__begin, __end);
  2325		      else if constexpr (__detail::__is_subrange<_Tp>)
  2326			return subrange<iterator_t<_Tp>>(__begin, __end);
  2327		      else
  2328			return iota_view(*__begin, *__end);
  2329		    }
  2330		  else if constexpr (__detail::__is_repeat_view<_Tp>)
  2331		    return __detail::__take_of_repeat_view(std::forward<_Range>(__r), __n);
  2332		  else
  2333		    return take_view(std::forward<_Range>(__r), __n);
  2334		}
  2335	
  2336	      using _RangeAdaptor<_Take>::operator();
  2337	      static constexpr int _S_arity = 2;
  2338	      // The count argument of views::take is not always simple -- it can be
  2339	      // e.g. a move-only class that's implicitly convertible to the difference
  2340	      // type.  But an integer-like count argument is surely simple.
  2341	      template<typename _Tp>
  2342		static constexpr bool _S_has_simple_extra_args
  2343		  = ranges::__detail::__is_integer_like<_Tp>;
  2344	    };
  2345	
  2346	    inline constexpr _Take take;
  2347	  } // namespace views
  2348	
  2349	  template<view _Vp, typename _Pred>
  2350	    requires input_range<_Vp> && is_object_v<_Pred>
  2351	      && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
  2352	    class take_while_view : public view_interface<take_while_view<_Vp, _Pred>>
  2353	    {
  2354	      template<bool _Const>
  2355		struct _Sentinel
  2356		{
  2357		private:
  2358		  using _Base = __detail::__maybe_const_t<_Const, _Vp>;
  2359	
  2360		  sentinel_t<_Base> _M_end = sentinel_t<_Base>();
  2361		  const _Pred* _M_pred = nullptr;
  2362	
  2363		public:
  2364		  _Sentinel() = default;
  2365	
  2366		  constexpr explicit
  2367		  _Sentinel(sentinel_t<_Base> __end, const _Pred* __pred)
  2368		    : _M_end(__end), _M_pred(__pred)
  2369		  { }
  2370	
  2371		  constexpr
  2372		  _Sentinel(_Sentinel<!_Const> __s)
  2373		    requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
  2374		    : _M_end(__s._M_end), _M_pred(__s._M_pred)
  2375		  { }
  2376	
  2377		  constexpr sentinel_t<_Base>
  2378		  base() const { return _M_end; }
  2379	
  2380		  friend constexpr bool
  2381		  operator==(const iterator_t<_Base>& __x, const _Sentinel& __y)
  2382		  { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
  2383	
  2384		  template<bool _OtherConst = !_Const,
  2385			   typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
  2386		    requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
  2387		  friend constexpr bool
  2388		  operator==(const iterator_t<_Base2>& __x, const _Sentinel& __y)
  2389		  { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
  2390	
  2391		  friend _Sentinel<!_Const>;
  2392		};
  2393	
  2394	      _Vp _M_base = _Vp();
  2395	      [[no_unique_address]] __detail::__box<_Pred> _M_pred;
  2396	
  2397	    public:
  2398	      take_while_view() requires (default_initializable<_Vp>
  2399					  && default_initializable<_Pred>)
  2400		= default;
  2401	
  2402	      constexpr
  2403	      take_while_view(_Vp __base, _Pred __pred)
  2404		: _M_base(std::move(__base)), _M_pred(std::move(__pred))
  2405	      { }
  2406	
  2407	      constexpr _Vp
  2408	      base() const& requires copy_constructible<_Vp>
  2409	      { return _M_base; }
  2410	
  2411	      constexpr _Vp
  2412	      base() &&
  2413	      { return std::move(_M_base); }
  2414	
  2415	      constexpr const _Pred&
  2416	      pred() const
  2417	      { return *_M_pred; }
  2418	
  2419	      constexpr auto
  2420	      begin() requires (!__detail::__simple_view<_Vp>)
  2421	      { return ranges::begin(_M_base); }
  2422	
  2423	      constexpr auto
  2424	      begin() const requires range<const _Vp>
  2425		&& indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
  2426	      { return ranges::begin(_M_base); }
  2427	
  2428	      constexpr auto
  2429	      end() requires (!__detail::__simple_view<_Vp>)
  2430	      { return _Sentinel<false>(ranges::end(_M_base),
  2431					std::__addressof(*_M_pred)); }
  2432	
  2433	      constexpr auto
  2434	      end() const requires range<const _Vp>
  2435		&& indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
  2436	      { return _Sentinel<true>(ranges::end(_M_base),
  2437				       std::__addressof(*_M_pred)); }
  2438	    };
  2439	
  2440	  template<typename _Range, typename _Pred>
  2441	    take_while_view(_Range&&, _Pred)
  2442	      -> take_while_view<views::all_t<_Range>, _Pred>;
  2443	
  2444	  namespace views
  2445	  {
  2446	    namespace __detail
  2447	    {
  2448	      template<typename _Range, typename _Pred>
  2449		concept __can_take_while_view
  2450		  = requires { take_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
  2451	    } // namespace __detail
  2452	
  2453	    struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
  2454	    {
  2455	      template<viewable_range _Range, typename _Pred>
  2456		requires __detail::__can_take_while_view<_Range, _Pred>
  2457		constexpr auto
  2458		operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
  2459		{
  2460		  return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
  2461		}
  2462	
  2463	      using _RangeAdaptor<_TakeWhile>::operator();
  2464	      static constexpr int _S_arity = 2;
  2465	      static constexpr bool _S_has_simple_extra_args = true;
  2466	    };
  2467	
  2468	    inline constexpr _TakeWhile take_while;
  2469	  } // namespace views
  2470	
  2471	  template<view _Vp>
  2472	    class drop_view : public view_interface<drop_view<_Vp>>
  2473	    {
  2474	    private:
  2475	      _Vp _M_base = _Vp();
  2476	      range_difference_t<_Vp> _M_count = 0;
  2477	
  2478	      // ranges::next(begin(base), count, end(base)) is O(1) if _Vp satisfies
  2479	      // both random_access_range and sized_range. Otherwise, cache its result.
  2480	      static constexpr bool _S_needs_cached_begin
  2481		= !(random_access_range<const _Vp> && sized_range<const _Vp>);
  2482	      [[no_unique_address]]
  2483		__detail::__maybe_present_t<_S_needs_cached_begin,
  2484					    __detail::_CachedPosition<_Vp>>
  2485					      _M_cached_begin;
  2486	
  2487	    public:
  2488	      drop_view() requires default_initializable<_Vp> = default;
  2489	
  2490	      constexpr
  2491	      drop_view(_Vp __base, range_difference_t<_Vp> __count)
  2492		: _M_base(std::move(__base)), _M_count(__count)
  2493	      { __glibcxx_assert(__count >= 0); }
  2494	
  2495	      constexpr _Vp
  2496	      base() const& requires copy_constructible<_Vp>
  2497	      { return _M_base; }
  2498	
  2499	      constexpr _Vp
  2500	      base() &&
  2501	      { return std::move(_M_base); }
  2502	
  2503	      // This overload is disabled for simple views with constant-time begin().
  2504	      constexpr auto
  2505	      begin()
  2506		requires (!(__detail::__simple_view<_Vp>
  2507			    && random_access_range<const _Vp>
  2508			    && sized_range<const _Vp>))
  2509	      {
  2510		if constexpr (_S_needs_cached_begin)
  2511		  if (_M_cached_begin._M_has_value())
  2512		    return _M_cached_begin._M_get(_M_base);
  2513	
  2514		auto __it = ranges::next(ranges::begin(_M_base),
  2515					 _M_count, ranges::end(_M_base));
  2516		if constexpr (_S_needs_cached_begin)
  2517		  _M_cached_begin._M_set(_M_base, __it);
  2518		return __it;
  2519	      }
  2520	
  2521	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
  2522	      // 3482. drop_view's const begin should additionally require sized_range
  2523	      constexpr auto
  2524	      begin() const
  2525		requires random_access_range<const _Vp> && sized_range<const _Vp>
  2526	      {
  2527		return ranges::next(ranges::begin(_M_base), _M_count,
  2528				    ranges::end(_M_base));
  2529	      }
  2530	
  2531	      constexpr auto
  2532	      end() requires (!__detail::__simple_view<_Vp>)
  2533	      { return ranges::end(_M_base); }
  2534	
  2535	      constexpr auto
  2536	      end() const requires range<const _Vp>
  2537	      { return ranges::end(_M_base); }
  2538	
  2539	      constexpr auto
  2540	      size() requires sized_range<_Vp>
  2541	      {
  2542		const auto __s = ranges::size(_M_base);
  2543		const auto __c = static_cast<decltype(__s)>(_M_count);
  2544		return __s < __c ? 0 : __s - __c;
  2545	      }
  2546	
  2547	      constexpr auto
  2548	      size() const requires sized_range<const _Vp>
  2549	      {
  2550		const auto __s = ranges::size(_M_base);
  2551		const auto __c = static_cast<decltype(__s)>(_M_count);
  2552		return __s < __c ? 0 : __s - __c;
  2553	      }
  2554	    };
  2555	
  2556	  template<typename _Range>
  2557	    drop_view(_Range&&, range_difference_t<_Range>)
  2558	      -> drop_view<views::all_t<_Range>>;
  2559	
  2560	  template<typename _Tp>
  2561	    inline constexpr bool enable_borrowed_range<drop_view<_Tp>>
  2562	      = enable_borrowed_range<_Tp>;
  2563	
  2564	  namespace views
  2565	  {
  2566	    namespace __detail
  2567	    {
  2568	      template<typename _Range>
  2569		constexpr auto
  2570		__drop_of_repeat_view(_Range&&, range_difference_t<_Range>); // defined later
  2571	
  2572	      template<typename _Range, typename _Dp>
  2573		concept __can_drop_view
  2574		  = requires { drop_view(std::declval<_Range>(), std::declval<_Dp>()); };
  2575	    } // namespace __detail
  2576	
  2577	    struct _Drop : __adaptor::_RangeAdaptor<_Drop>
  2578	    {
  2579	      template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
  2580		requires __detail::__can_drop_view<_Range, _Dp>
  2581		constexpr auto
  2582		operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
  2583		{
  2584		  using _Tp = remove_cvref_t<_Range>;
  2585		  if constexpr (__detail::__is_empty_view<_Tp>)
  2586		    return _Tp();
  2587		  else if constexpr (random_access_range<_Tp>
  2588				     && sized_range<_Tp>
  2589				     && (std::__detail::__is_span<_Tp>
  2590					 || __detail::__is_basic_string_view<_Tp>
  2591					 || __detail::__is_iota_view<_Tp>
  2592					 || __detail::__is_subrange<_Tp>))
  2593		    {
  2594		      __n = std::min<_Dp>(ranges::distance(__r), __n);
  2595		      auto __begin = ranges::begin(__r) + __n;
  2596		      auto __end = ranges::end(__r);
  2597		      if constexpr (std::__detail::__is_span<_Tp>)
  2598			return span<typename _Tp::element_type>(__begin, __end);
  2599		      else if constexpr (__detail::__is_subrange<_Tp>)
  2600			{
  2601			  if constexpr (_Tp::_S_store_size)
  2602			    {
  2603			      using ranges::__detail::__to_unsigned_like;
  2604			      auto __m = ranges::distance(__r) - __n;
  2605			      return _Tp(__begin, __end, __to_unsigned_like(__m));
  2606			    }
  2607			  else
  2608			    return _Tp(__begin, __end);
  2609			}
  2610		      else
  2611			return _Tp(__begin, __end);
  2612		    }
  2613		  else if constexpr (__detail::__is_repeat_view<_Tp>)
  2614		    return __detail::__drop_of_repeat_view(std::forward<_Range>(__r), __n);
  2615		  else
  2616		    return drop_view(std::forward<_Range>(__r), __n);
  2617		}
  2618	
  2619	      using _RangeAdaptor<_Drop>::operator();
  2620	      static constexpr int _S_arity = 2;
  2621	      template<typename _Tp>
  2622		static constexpr bool _S_has_simple_extra_args
  2623		  = _Take::_S_has_simple_extra_args<_Tp>;
  2624	    };
  2625	
  2626	    inline constexpr _Drop drop;
  2627	  } // namespace views
  2628	
  2629	  template<view _Vp, typename _Pred>
  2630	    requires input_range<_Vp> && is_object_v<_Pred>
  2631	      && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
  2632	    class drop_while_view : public view_interface<drop_while_view<_Vp, _Pred>>
  2633	    {
  2634	    private:
  2635	      _Vp _M_base = _Vp();
  2636	      [[no_unique_address]] __detail::__box<_Pred> _M_pred;
  2637	      [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
  2638	
  2639	    public:
  2640	      drop_while_view() requires (default_initializable<_Vp>
  2641					  && default_initializable<_Pred>)
  2642		= default;
  2643	
  2644	      constexpr
  2645	      drop_while_view(_Vp __base, _Pred __pred)
  2646		: _M_base(std::move(__base)), _M_pred(std::move(__pred))
  2647	      { }
  2648	
  2649	      constexpr _Vp
  2650	      base() const& requires copy_constructible<_Vp>
  2651	      { return _M_base; }
  2652	
  2653	      constexpr _Vp
  2654	      base() &&
  2655	      { return std::move(_M_base); }
  2656	
  2657	      constexpr const _Pred&
  2658	      pred() const
  2659	      { return *_M_pred; }
  2660	
  2661	      constexpr auto
  2662	      begin()
  2663	      {
  2664		if (_M_cached_begin._M_has_value())
  2665		  return _M_cached_begin._M_get(_M_base);
  2666	
  2667		__glibcxx_assert(_M_pred.has_value());
  2668		auto __it = ranges::find_if_not(ranges::begin(_M_base),
  2669						ranges::end(_M_base),
  2670						std::cref(*_M_pred));
  2671		_M_cached_begin._M_set(_M_base, __it);
  2672		return __it;
  2673	      }
  2674	
  2675	      constexpr auto
  2676	      end()
  2677	      { return ranges::end(_M_base); }
  2678	    };
  2679	
  2680	  template<typename _Range, typename _Pred>
  2681	    drop_while_view(_Range&&, _Pred)
  2682	      -> drop_while_view<views::all_t<_Range>, _Pred>;
  2683	
  2684	  template<typename _Tp, typename _Pred>
  2685	    inline constexpr bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
  2686	      = enable_borrowed_range<_Tp>;
  2687	
  2688	  namespace views
  2689	  {
  2690	    namespace __detail
  2691	    {
  2692	      template<typename _Range, typename _Pred>
  2693		concept __can_drop_while_view
  2694		  = requires { drop_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
  2695	    } // namespace __detail
  2696	
  2697	    struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
  2698	    {
  2699	      template<viewable_range _Range, typename _Pred>
  2700		requires __detail::__can_drop_while_view<_Range, _Pred>
  2701		constexpr auto
  2702		operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
  2703		{
  2704		  return drop_while_view(std::forward<_Range>(__r),
  2705					 std::forward<_Pred>(__p));
  2706		}
  2707	
  2708	      using _RangeAdaptor<_DropWhile>::operator();
  2709	      static constexpr int _S_arity = 2;
  2710	      static constexpr bool _S_has_simple_extra_args = true;
  2711	    };
  2712	
  2713	    inline constexpr _DropWhile drop_while;
  2714	  } // namespace views
  2715	
  2716	  template<input_range _Vp>
  2717	    requires view<_Vp> && input_range<range_reference_t<_Vp>>
  2718	    class join_view : public view_interface<join_view<_Vp>>
  2719	    {
  2720	    private:
  2721	      using _InnerRange = range_reference_t<_Vp>;
  2722	
  2723	      template<bool _Const>
  2724		using _Base = __detail::__maybe_const_t<_Const, _Vp>;
  2725	
  2726	      template<bool _Const>
  2727		using _Outer_iter = iterator_t<_Base<_Const>>;
  2728	
  2729	      template<bool _Const>
  2730		using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
  2731	
  2732	      template<bool _Const>
  2733		static constexpr bool _S_ref_is_glvalue
  2734		  = is_reference_v<range_reference_t<_Base<_Const>>>;
  2735	
  2736	      template<bool _Const>
  2737		struct __iter_cat
  2738		{ };
  2739	
  2740	      template<bool _Const>
  2741		requires _S_ref_is_glvalue<_Const>
  2742		  && forward_range<_Base<_Const>>
  2743		  && forward_range<range_reference_t<_Base<_Const>>>
  2744		struct __iter_cat<_Const>
  2745		{
  2746		private:
  2747		  static constexpr auto
  2748		  _S_iter_cat()
  2749		  {
  2750		    using _Outer_iter = join_view::_Outer_iter<_Const>;
  2751		    using _Inner_iter = join_view::_Inner_iter<_Const>;
  2752		    using _OuterCat = typename iterator_traits<_Outer_iter>::iterator_category;
  2753		    using _InnerCat = typename iterator_traits<_Inner_iter>::iterator_category;
  2754		    if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
  2755				  && derived_from<_InnerCat, bidirectional_iterator_tag>
  2756				  && common_range<range_reference_t<_Base<_Const>>>)
  2757		      return bidirectional_iterator_tag{};
  2758		    else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
  2759				       && derived_from<_InnerCat, forward_iterator_tag>)
  2760		      return forward_iterator_tag{};
  2761		    else
  2762		      return input_iterator_tag{};
  2763		  }
  2764		public:
  2765		  using iterator_category = decltype(_S_iter_cat());
  2766		};
  2767	
  2768	      template<bool _Const>
  2769		struct _Sentinel;
  2770	
  2771	      template<bool _Const>
  2772		struct _Iterator : __iter_cat<_Const>
  2773		{
  2774		private:
  2775		  using _Parent = __detail::__maybe_const_t<_Const, join_view>;
  2776		  using _Base = join_view::_Base<_Const>;
  2777	
  2778		  static constexpr bool _S_ref_is_glvalue
  2779		    = join_view::_S_ref_is_glvalue<_Const>;
  2780	
  2781		  constexpr void
  2782		  _M_satisfy()
  2783		  {
  2784		    auto __update_inner = [this] (const iterator_t<_Base>& __x) -> auto&& {
  2785		      if constexpr (_S_ref_is_glvalue)
  2786			return *__x;
  2787		      else
  2788			return _M_parent->_M_inner._M_emplace_deref(__x);
  2789		    };
  2790	
  2791		    for (; _M_outer != ranges::end(_M_parent->_M_base); ++_M_outer)
  2792		      {
  2793			auto&& __inner = __update_inner(_M_outer);
  2794			_M_inner = ranges::begin(__inner);
  2795			if (_M_inner != ranges::end(__inner))
  2796			  return;
  2797		      }
  2798	
  2799		    if constexpr (_S_ref_is_glvalue)
  2800		      _M_inner.reset();
  2801		  }
  2802	
  2803		  static constexpr auto
  2804		  _S_iter_concept()
  2805		  {
  2806		    if constexpr (_S_ref_is_glvalue
  2807				  && bidirectional_range<_Base>
  2808				  && bidirectional_range<range_reference_t<_Base>>
  2809				  && common_range<range_reference_t<_Base>>)
  2810		      return bidirectional_iterator_tag{};
  2811		    else if constexpr (_S_ref_is_glvalue
  2812				       && forward_range<_Base>
  2813				       && forward_range<range_reference_t<_Base>>)
  2814		      return forward_iterator_tag{};
  2815		    else
  2816		      return input_iterator_tag{};
  2817		  }
  2818	
  2819		  using _Outer_iter = join_view::_Outer_iter<_Const>;
  2820		  using _Inner_iter = join_view::_Inner_iter<_Const>;
  2821	
  2822		  _Outer_iter _M_outer = _Outer_iter();
  2823		  optional<_Inner_iter> _M_inner;
  2824		  _Parent* _M_parent = nullptr;
  2825	
  2826		public:
  2827		  using iterator_concept = decltype(_S_iter_concept());
  2828		  // iterator_category defined in __join_view_iter_cat
  2829		  using value_type = range_value_t<range_reference_t<_Base>>;
  2830		  using difference_type
  2831		    = common_type_t<range_difference_t<_Base>,
  2832				    range_difference_t<range_reference_t<_Base>>>;
  2833	
  2834		  _Iterator() requires default_initializable<_Outer_iter> = default;
  2835	
  2836		  constexpr
  2837		  _Iterator(_Parent* __parent, _Outer_iter __outer)
  2838		    : _M_outer(std::move(__outer)),
  2839		      _M_parent(__parent)
  2840		  { _M_satisfy(); }
  2841	
  2842		  constexpr
  2843		  _Iterator(_Iterator<!_Const> __i)
  2844		    requires _Const
  2845		      && convertible_to<iterator_t<_Vp>, _Outer_iter>
  2846		      && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
  2847		    : _M_outer(std::move(__i._M_outer)), _M_inner(std::move(__i._M_inner)),
  2848		      _M_parent(__i._M_parent)
  2849		  { }
  2850	
  2851		  constexpr decltype(auto)
  2852		  operator*() const
  2853		  { return **_M_inner; }
  2854	
  2855		  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  2856		  // 3500. join_view::iterator::operator->() is bogus
  2857		  constexpr _Inner_iter
  2858		  operator->() const
  2859		    requires __detail::__has_arrow<_Inner_iter>
  2860		      && copyable<_Inner_iter>
  2861		  { return *_M_inner; }
  2862	
  2863		  constexpr _Iterator&
  2864		  operator++()
  2865		  {
  2866		    auto&& __inner_range = [this] () -> auto&& {
  2867		      if constexpr (_S_ref_is_glvalue)
  2868			return *_M_outer;
  2869		      else
  2870			return *_M_parent->_M_inner;
  2871		    }();
  2872		    if (++*_M_inner == ranges::end(__inner_range))
  2873		      {
  2874			++_M_outer;
  2875			_M_satisfy();
  2876		      }
  2877		    return *this;
  2878		  }
  2879	
  2880		  constexpr void
  2881		  operator++(int)
  2882		  { ++*this; }
  2883	
  2884		  constexpr _Iterator
  2885		  operator++(int)
  2886		    requires _S_ref_is_glvalue && forward_range<_Base>
  2887		      && forward_range<range_reference_t<_Base>>
  2888		  {
  2889		    auto __tmp = *this;
  2890		    ++*this;
  2891		    return __tmp;
  2892		  }
  2893	
  2894		  constexpr _Iterator&
  2895		  operator--()
  2896		    requires _S_ref_is_glvalue && bidirectional_range<_Base>
  2897		      && bidirectional_range<range_reference_t<_Base>>
  2898		      && common_range<range_reference_t<_Base>>
  2899		  {
  2900		    if (_M_outer == ranges::end(_M_parent->_M_base))
  2901		      _M_inner = ranges::end(*--_M_outer);
  2902		    while (*_M_inner == ranges::begin(*_M_outer))
  2903		      *_M_inner = ranges::end(*--_M_outer);
  2904		    --*_M_inner;
  2905		    return *this;
  2906		  }
  2907	
  2908		  constexpr _Iterator
  2909		  operator--(int)
  2910		    requires _S_ref_is_glvalue && bidirectional_range<_Base>
  2911		      && bidirectional_range<range_reference_t<_Base>>
  2912		      && common_range<range_reference_t<_Base>>
  2913		  {
  2914		    auto __tmp = *this;
  2915		    --*this;
  2916		    return __tmp;
  2917		  }
  2918	
  2919		  friend constexpr bool
  2920		  operator==(const _Iterator& __x, const _Iterator& __y)
  2921		    requires _S_ref_is_glvalue
  2922		      && equality_comparable<_Outer_iter>
  2923		      && equality_comparable<_Inner_iter>
  2924		  {
  2925		    return (__x._M_outer == __y._M_outer
  2926			    && __x._M_inner == __y._M_inner);
  2927		  }
  2928	
  2929		  friend constexpr decltype(auto)
  2930		  iter_move(const _Iterator& __i)
  2931		  noexcept(noexcept(ranges::iter_move(*__i._M_inner)))
  2932		  { return ranges::iter_move(*__i._M_inner); }
  2933	
  2934		  friend constexpr void
  2935		  iter_swap(const _Iterator& __x, const _Iterator& __y)
  2936		    noexcept(noexcept(ranges::iter_swap(*__x._M_inner, *__y._M_inner)))
  2937		    requires indirectly_swappable<_Inner_iter>
  2938		  { return ranges::iter_swap(*__x._M_inner, *__y._M_inner); }
  2939	
  2940		  friend _Iterator<!_Const>;
  2941		  template<bool> friend struct _Sentinel;
  2942		};
  2943	
  2944	      template<bool _Const>
  2945		struct _Sentinel
  2946		{
  2947		private:
  2948		  using _Parent = __detail::__maybe_const_t<_Const, join_view>;
  2949		  using _Base = join_view::_Base<_Const>;
  2950	
  2951		  template<bool _Const2>
  2952		    constexpr bool
  2953		    __equal(const _Iterator<_Const2>& __i) const
  2954		    { return __i._M_outer == _M_end; }
  2955	
  2956		  sentinel_t<_Base> _M_end = sentinel_t<_Base>();
  2957	
  2958		public:
  2959		  _Sentinel() = default;
  2960	
  2961		  constexpr explicit
  2962		  _Sentinel(_Parent* __parent)
  2963		    : _M_end(ranges::end(__parent->_M_base))
  2964		  { }
  2965	
  2966		  constexpr
  2967		  _Sentinel(_Sentinel<!_Const> __s)
  2968		    requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
  2969		    : _M_end(std::move(__s._M_end))
  2970		  { }
  2971	
  2972		  template<bool _Const2>
  2973		    requires sentinel_for<sentinel_t<_Base>,
  2974			       iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
  2975		    friend constexpr bool
  2976		    operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
  2977		    { return __y.__equal(__x); }
  2978	
  2979		  friend _Sentinel<!_Const>;
  2980		};
  2981	
  2982	      _Vp _M_base = _Vp();
  2983	      [[no_unique_address]]
  2984		__detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
  2985	
  2986	    public:
  2987	      join_view() requires default_initializable<_Vp> = default;
  2988	
  2989	      constexpr explicit
  2990	      join_view(_Vp __base)
  2991		: _M_base(std::move(__base))
  2992	      { }
  2993	
  2994	      constexpr _Vp
  2995	      base() const& requires copy_constructible<_Vp>
  2996	      { return _M_base; }
  2997	
  2998	      constexpr _Vp
  2999	      base() &&
  3000	      { return std::move(_M_base); }
  3001	
  3002	      constexpr auto
  3003	      begin()
  3004	      {
  3005		constexpr bool __use_const
  3006		  = (__detail::__simple_view<_Vp>
  3007		     && is_reference_v<range_reference_t<_Vp>>);
  3008		return _Iterator<__use_const>{this, ranges::begin(_M_base)};
  3009	      }
  3010	
  3011	      constexpr auto
  3012	      begin() const
  3013		requires input_range<const _Vp>
  3014		  && is_reference_v<range_reference_t<const _Vp>>
  3015	      {
  3016		return _Iterator<true>{this, ranges::begin(_M_base)};
  3017	      }
  3018	
  3019	      constexpr auto
  3020	      end()
  3021	      {
  3022		if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
  3023			      && forward_range<_InnerRange>
  3024			      && common_range<_Vp> && common_range<_InnerRange>)
  3025		  return _Iterator<__detail::__simple_view<_Vp>>{this,
  3026								 ranges::end(_M_base)};
  3027		else
  3028		  return _Sentinel<__detail::__simple_view<_Vp>>{this};
  3029	      }
  3030	
  3031	      constexpr auto
  3032	      end() const
  3033		requires input_range<const _Vp>
  3034		  && is_reference_v<range_reference_t<const _Vp>>
  3035	      {
  3036		if constexpr (forward_range<const _Vp>
  3037			      && is_reference_v<range_reference_t<const _Vp>>
  3038			      && forward_range<range_reference_t<const _Vp>>
  3039			      && common_range<const _Vp>
  3040			      && common_range<range_reference_t<const _Vp>>)
  3041		  return _Iterator<true>{this, ranges::end(_M_base)};
  3042		else
  3043		  return _Sentinel<true>{this};
  3044	      }
  3045	    };
  3046	
  3047	  template<typename _Range>
  3048	    explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
  3049	
  3050	  namespace views
  3051	  {
  3052	    namespace __detail
  3053	    {
  3054	      template<typename _Range>
  3055		concept __can_join_view
  3056		  = requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
  3057	    } // namespace __detail
  3058	
  3059	    struct _Join : __adaptor::_RangeAdaptorClosure
  3060	    {
  3061	      template<viewable_range _Range>
  3062		requires __detail::__can_join_view<_Range>
  3063		constexpr auto
  3064		operator() [[nodiscard]] (_Range&& __r) const
  3065		{
  3066		  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  3067		  // 3474. Nesting join_views is broken because of CTAD
  3068		  return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
  3069		}
  3070	
  3071	      static constexpr bool _S_has_simple_call_op = true;
  3072	    };
  3073	
  3074	    inline constexpr _Join join;
  3075	  } // namespace views
  3076	
  3077	  namespace __detail
  3078	  {
  3079	    template<auto>
  3080	      struct __require_constant;
  3081	
  3082	    template<typename _Range>
  3083	      concept __tiny_range = sized_range<_Range>
  3084		&& requires
  3085		   { typename __require_constant<remove_reference_t<_Range>::size()>; }
  3086		&& (remove_reference_t<_Range>::size() <= 1);
  3087	
  3088	    template<typename _Base>
  3089	      struct __lazy_split_view_outer_iter_cat
  3090	      { };
  3091	
  3092	    template<forward_range _Base>
  3093	      struct __lazy_split_view_outer_iter_cat<_Base>
  3094	      { using iterator_category = input_iterator_tag; };
  3095	
  3096	    template<typename _Base>
  3097	      struct __lazy_split_view_inner_iter_cat
  3098	      { };
  3099	
  3100	    template<forward_range _Base>
  3101	      struct __lazy_split_view_inner_iter_cat<_Base>
  3102	      {
  3103	      private:
  3104		static constexpr auto
  3105		_S_iter_cat()
  3106		{
  3107		  using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
  3108		  if constexpr (derived_from<_Cat, forward_iterator_tag>)
  3109		    return forward_iterator_tag{};
  3110		  else
  3111		    return _Cat{};
  3112		}
  3113	      public:
  3114		using iterator_category = decltype(_S_iter_cat());
  3115	      };
  3116	  }
  3117	
  3118	  template<input_range _Vp, forward_range _Pattern>
  3119	    requires view<_Vp> && view<_Pattern>
  3120	      && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
  3121				       ranges::equal_to>
  3122	      && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
  3123	    class lazy_split_view : public view_interface<lazy_split_view<_Vp, _Pattern>>
  3124	    {
  3125	    private:
  3126	      template<bool _Const>
  3127		using _Base = __detail::__maybe_const_t<_Const, _Vp>;
  3128	
  3129	      template<bool _Const>
  3130		struct _InnerIter;
  3131	
  3132	      template<bool _Const>
  3133		struct _OuterIter
  3134		  : __detail::__lazy_split_view_outer_iter_cat<_Base<_Const>>
  3135		{
  3136		private:
  3137		  using _Parent = __detail::__maybe_const_t<_Const, lazy_split_view>;
  3138		  using _Base = lazy_split_view::_Base<_Const>;
  3139	
  3140		  constexpr bool
  3141		  __at_end() const
  3142		  { return __current() == ranges::end(_M_parent->_M_base) && !_M_trailing_empty; }
  3143	
  3144		  // [range.lazy.split.outer] p1
  3145		  //  Many of the following specifications refer to the notional member
  3146		  //  current of outer-iterator.  current is equivalent to current_ if
  3147		  //  V models forward_range, and parent_->current_ otherwise.
  3148		  constexpr auto&
  3149		  __current() noexcept
  3150		  {
  3151		    if constexpr (forward_range<_Vp>)
  3152		      return _M_current;
  3153		    else
  3154		      return *_M_parent->_M_current;
  3155		  }
  3156	
  3157		  constexpr auto&
  3158		  __current() const noexcept
  3159		  {
  3160		    if constexpr (forward_range<_Vp>)
  3161		      return _M_current;
  3162		    else
  3163		      return *_M_parent->_M_current;
  3164		  }
  3165	
  3166		  _Parent* _M_parent = nullptr;
  3167	
  3168		  [[no_unique_address]]
  3169		    __detail::__maybe_present_t<forward_range<_Vp>,
  3170						iterator_t<_Base>> _M_current;
  3171		  bool _M_trailing_empty = false;
  3172	
  3173		public:
  3174		  using iterator_concept = __conditional_t<forward_range<_Base>,
  3175							   forward_iterator_tag,
  3176							   input_iterator_tag>;
  3177		  // iterator_category defined in __lazy_split_view_outer_iter_cat
  3178		  using difference_type = range_difference_t<_Base>;
  3179	
  3180		  struct value_type : view_interface<value_type>
  3181		  {
  3182		  private:
  3183		    _OuterIter _M_i = _OuterIter();
  3184	
  3185		  public:
  3186		    value_type() = default;
  3187	
  3188		    constexpr explicit
  3189		    value_type(_OuterIter __i)
  3190		      : _M_i(std::move(__i))
  3191		    { }
  3192	
  3193		    constexpr _InnerIter<_Const>
  3194		    begin() const
  3195		    { return _InnerIter<_Const>{_M_i}; }
  3196	
  3197		    constexpr default_sentinel_t
  3198		    end() const noexcept
  3199		    { return default_sentinel; }
  3200		  };
  3201	
  3202		  _OuterIter() = default;
  3203	
  3204		  constexpr explicit
  3205		  _OuterIter(_Parent* __parent) requires (!forward_range<_Base>)
  3206		    : _M_parent(__parent)
  3207		  { }
  3208	
  3209		  constexpr
  3210		  _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
  3211		    requires forward_range<_Base>
  3212		    : _M_parent(__parent),
  3213		      _M_current(std::move(__current))
  3214		  { }
  3215	
  3216		  constexpr
  3217		  _OuterIter(_OuterIter<!_Const> __i)
  3218		    requires _Const
  3219		      && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
  3220		    : _M_parent(__i._M_parent), _M_current(std::move(__i._M_current)),
  3221		      _M_trailing_empty(__i._M_trailing_empty)
  3222		  { }
  3223	
  3224		  constexpr value_type
  3225		  operator*() const
  3226		  { return value_type{*this}; }
  3227	
  3228		  constexpr _OuterIter&
  3229		  operator++()
  3230		  {
  3231		    // _GLIBCXX_RESOLVE_LIB_DEFECTS
  3232		    // 3505. lazy_split_view::outer-iterator::operator++ misspecified
  3233		    const auto __end = ranges::end(_M_parent->_M_base);
  3234		    if (__current() == __end)
  3235		      {
  3236			_M_trailing_empty = false;
  3237			return *this;
  3238		      }
  3239		    const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
  3240		    if (__pbegin == __pend)
  3241		      ++__current();
  3242		    else if constexpr (__detail::__tiny_range<_Pattern>)
  3243		      {
  3244			__current() = ranges::find(std::move(__current()), __end,
  3245						   *__pbegin);
  3246			if (__current() != __end)
  3247			  {
  3248			    ++__current();
  3249			    if (__current() == __end)
  3250			      _M_trailing_empty = true;
  3251			  }
  3252		      }
  3253		    else
  3254		      do
  3255			{
  3256			  auto [__b, __p]
  3257			    = ranges::mismatch(__current(), __end, __pbegin, __pend);
  3258			  if (__p == __pend)
  3259			    {
  3260			      __current() = __b;
  3261			      if (__current() == __end)
  3262				_M_trailing_empty = true;
  3263			      break;
  3264			    }
  3265			} while (++__current() != __end);
  3266		    return *this;
  3267		  }
  3268	
  3269		  constexpr decltype(auto)
  3270		  operator++(int)
  3271		  {
  3272		    if constexpr (forward_range<_Base>)
  3273		      {
  3274			auto __tmp = *this;
  3275			++*this;
  3276			return __tmp;
  3277		      }
  3278		    else
  3279		      ++*this;
  3280		  }
  3281	
  3282		  friend constexpr bool
  3283		  operator==(const _OuterIter& __x, const _OuterIter& __y)
  3284		    requires forward_range<_Base>
  3285		  {
  3286		    return __x._M_current == __y._M_current
  3287		      && __x._M_trailing_empty == __y._M_trailing_empty;
  3288		  }
  3289	
  3290		  friend constexpr bool
  3291		  operator==(const _OuterIter& __x, default_sentinel_t)
  3292		  { return __x.__at_end(); };
  3293	
  3294		  friend _OuterIter<!_Const>;
  3295		  friend _InnerIter<_Const>;
  3296		};
  3297	
  3298	      template<bool _Const>
  3299		struct _InnerIter
  3300		  : __detail::__lazy_split_view_inner_iter_cat<_Base<_Const>>
  3301		{
  3302		private:
  3303		  using _Base = lazy_split_view::_Base<_Const>;
  3304	
  3305		  constexpr bool
  3306		  __at_end() const
  3307		  {
  3308		    auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
  3309		    auto __end = ranges::end(_M_i._M_parent->_M_base);
  3310		    if constexpr (__detail::__tiny_range<_Pattern>)
  3311		      {
  3312			const auto& __cur = _M_i_current();
  3313			if (__cur == __end)
  3314			  return true;
  3315			if (__pcur == __pend)
  3316			  return _M_incremented;
  3317			return *__cur == *__pcur;
  3318		      }
  3319		    else
  3320		      {
  3321			auto __cur = _M_i_current();
  3322			if (__cur == __end)
  3323			  return true;
  3324			if (__pcur == __pend)
  3325			  return _M_incremented;
  3326			do
  3327			  {
  3328			    if (*__cur != *__pcur)
  3329			      return false;
  3330			    if (++__pcur == __pend)
  3331			      return true;
  3332			  } while (++__cur != __end);
  3333			return false;
  3334		      }
  3335		  }
  3336	
  3337		  constexpr auto&
  3338		  _M_i_current() noexcept
  3339		  { return _M_i.__current(); }
  3340	
  3341		  constexpr auto&
  3342		  _M_i_current() const noexcept
  3343		  { return _M_i.__current(); }
  3344	
  3345		  _OuterIter<_Const> _M_i = _OuterIter<_Const>();
  3346		  bool _M_incremented = false;
  3347	
  3348		public:
  3349		  using iterator_concept
  3350		    = typename _OuterIter<_Const>::iterator_concept;
  3351		  // iterator_category defined in __lazy_split_view_inner_iter_cat
  3352		  using value_type = range_value_t<_Base>;
  3353		  using difference_type = range_difference_t<_Base>;
  3354	
  3355		  _InnerIter() = default;
  3356	
  3357		  constexpr explicit
  3358		  _InnerIter(_OuterIter<_Const> __i)
  3359		    : _M_i(std::move(__i))
  3360		  { }
  3361	
  3362		  constexpr const iterator_t<_Base>&
  3363		  base() const& noexcept
  3364		  { return _M_i_current(); }
  3365	
  3366		  constexpr iterator_t<_Base>
  3367		  base() && requires forward_range<_Vp>
  3368		  { return std::move(_M_i_current()); }
  3369	
  3370		  constexpr decltype(auto)
  3371		  operator*() const
  3372		  { return *_M_i_current(); }
  3373	
  3374		  constexpr _InnerIter&
  3375		  operator++()
  3376		  {
  3377		    _M_incremented = true;
  3378		    if constexpr (!forward_range<_Base>)
  3379		      if constexpr (_Pattern::size() == 0)
  3380			return *this;
  3381		    ++_M_i_current();
  3382		    return *this;
  3383		  }
  3384	
  3385		  constexpr decltype(auto)
  3386		  operator++(int)
  3387		  {
  3388		    if constexpr (forward_range<_Base>)
  3389		      {
  3390			auto __tmp = *this;
  3391			++*this;
  3392			return __tmp;
  3393		      }
  3394		    else
  3395		      ++*this;
  3396		  }
  3397	
  3398		  friend constexpr bool
  3399		  operator==(const _InnerIter& __x, const _InnerIter& __y)
  3400		    requires forward_range<_Base>
  3401		  { return __x._M_i == __y._M_i; }
  3402	
  3403		  friend constexpr bool
  3404		  operator==(const _InnerIter& __x, default_sentinel_t)
  3405		  { return __x.__at_end(); }
  3406	
  3407		  friend constexpr decltype(auto)
  3408		  iter_move(const _InnerIter& __i)
  3409		    noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
  3410		  { return ranges::iter_move(__i._M_i_current()); }
  3411	
  3412		  friend constexpr void
  3413		  iter_swap(const _InnerIter& __x, const _InnerIter& __y)
  3414		    noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
  3415							__y._M_i_current())))
  3416		    requires indirectly_swappable<iterator_t<_Base>>
  3417		  { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
  3418		};
  3419	
  3420	      _Vp _M_base = _Vp();
  3421	      _Pattern _M_pattern = _Pattern();
  3422	      [[no_unique_address]]
  3423		__detail::__maybe_present_t<!forward_range<_Vp>,
  3424		  __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_current;
  3425	
  3426	
  3427	    public:
  3428	      lazy_split_view() requires (default_initializable<_Vp>
  3429					  && default_initializable<_Pattern>)
  3430		= default;
  3431	
  3432	      constexpr
  3433	      lazy_split_view(_Vp __base, _Pattern __pattern)
  3434		: _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
  3435	      { }
  3436	
  3437	      template<input_range _Range>
  3438		requires constructible_from<_Vp, views::all_t<_Range>>
  3439		  && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
  3440		constexpr
  3441		lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
  3442		  : _M_base(views::all(std::forward<_Range>(__r))),
  3443		    _M_pattern(views::single(std::move(__e)))
  3444		{ }
  3445	
  3446	      constexpr _Vp
  3447	      base() const& requires copy_constructible<_Vp>
  3448	      { return _M_base; }
  3449	
  3450	      constexpr _Vp
  3451	      base() &&
  3452	      { return std::move(_M_base); }
  3453	
  3454	      constexpr auto
  3455	      begin()
  3456	      {
  3457		if constexpr (forward_range<_Vp>)
  3458		  {
  3459		    constexpr bool __simple
  3460		      = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
  3461		    return _OuterIter<__simple>{this, ranges::begin(_M_base)};
  3462		  }
  3463		else
  3464		  {
  3465		    _M_current = ranges::begin(_M_base);
  3466		    return _OuterIter<false>{this};
  3467		  }
  3468	      }
  3469	
  3470	      constexpr auto
  3471	      begin() const requires forward_range<_Vp> && forward_range<const _Vp>
  3472	      {
  3473		return _OuterIter<true>{this, ranges::begin(_M_base)};
  3474	      }
  3475	
  3476	      constexpr auto
  3477	      end() requires forward_range<_Vp> && common_range<_Vp>
  3478	      {
  3479		constexpr bool __simple
  3480		  = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
  3481		return _OuterIter<__simple>{this, ranges::end(_M_base)};
  3482	      }
  3483	
  3484	      constexpr auto
  3485	      end() const
  3486	      {
  3487		if constexpr (forward_range<_Vp>
  3488			      && forward_range<const _Vp>
  3489			      && common_range<const _Vp>)
  3490		  return _OuterIter<true>{this, ranges::end(_M_base)};
  3491		else
  3492		  return default_sentinel;
  3493	      }
  3494	    };
  3495	
  3496	  template<typename _Range, typename _Pattern>
  3497	    lazy_split_view(_Range&&, _Pattern&&)
  3498	      -> lazy_split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
  3499	
  3500	  template<input_range _Range>
  3501	    lazy_split_view(_Range&&, range_value_t<_Range>)
  3502	      -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
  3503	
  3504	  namespace views
  3505	  {
  3506	    namespace __detail
  3507	    {
  3508	      template<typename _Range, typename _Pattern>
  3509		concept __can_lazy_split_view
  3510		  = requires { lazy_split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
  3511	    } // namespace __detail
  3512	
  3513	    struct _LazySplit : __adaptor::_RangeAdaptor<_LazySplit>
  3514	    {
  3515	      template<viewable_range _Range, typename _Pattern>
  3516		requires __detail::__can_lazy_split_view<_Range, _Pattern>
  3517		constexpr auto
  3518		operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
  3519		{
  3520		  return lazy_split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
  3521		}
  3522	
  3523	      using _RangeAdaptor<_LazySplit>::operator();
  3524	      static constexpr int _S_arity = 2;
  3525	      // The pattern argument of views::lazy_split is not always simple -- it can be
  3526	      // a non-view range, the value category of which affects whether the call
  3527	      // is well-formed.  But a scalar or a view pattern argument is surely
  3528	      // simple.
  3529	      template<typename _Pattern>
  3530		static constexpr bool _S_has_simple_extra_args
  3531		  = is_scalar_v<_Pattern> || (view<_Pattern>
  3532					      && copy_constructible<_Pattern>);
  3533	    };
  3534	
  3535	    inline constexpr _LazySplit lazy_split;
  3536	  } // namespace views
  3537	
  3538	  template<forward_range _Vp, forward_range _Pattern>
  3539	    requires view<_Vp> && view<_Pattern>
  3540	      && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
  3541				       ranges::equal_to>
  3542	  class split_view : public view_interface<split_view<_Vp, _Pattern>>
  3543	  {
  3544	  private:
  3545	    _Vp _M_base = _Vp();
  3546	    _Pattern _M_pattern = _Pattern();
  3547	    __detail::__non_propagating_cache<subrange<iterator_t<_Vp>>> _M_cached_begin;
  3548	
  3549	    struct _Iterator;
  3550	    struct _Sentinel;
  3551	
  3552	  public:
  3553	    split_view() requires (default_initializable<_Vp>
  3554				   && default_initializable<_Pattern>)
  3555	      = default;
  3556	
  3557	    constexpr
  3558	    split_view(_Vp __base, _Pattern __pattern)
  3559	      : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
  3560	    { }
  3561	
  3562	    template<forward_range _Range>
  3563	      requires constructible_from<_Vp, views::all_t<_Range>>
  3564		&& constructible_from<_Pattern, single_view<range_value_t<_Range>>>
  3565	    constexpr
  3566	    split_view(_Range&& __r, range_value_t<_Range> __e)
  3567	      : _M_base(views::all(std::forward<_Range>(__r))),
  3568		_M_pattern(views::single(std::move(__e)))
  3569	    { }
  3570	
  3571	    constexpr _Vp
  3572	    base() const& requires copy_constructible<_Vp>
  3573	    { return _M_base; }
  3574	
  3575	    constexpr _Vp
  3576	    base() &&
  3577	    { return std::move(_M_base); }
  3578	
  3579	    constexpr _Iterator
  3580	    begin()
  3581	    {
  3582	      if (!_M_cached_begin)
  3583		_M_cached_begin = _M_find_next(ranges::begin(_M_base));
  3584	      return {this, ranges::begin(_M_base), *_M_cached_begin};
  3585	    }
  3586	
  3587	    constexpr auto
  3588	    end()
  3589	    {
  3590	      if constexpr (common_range<_Vp>)
  3591		return _Iterator{this, ranges::end(_M_base), {}};
  3592	      else
  3593		return _Sentinel{this};
  3594	    }
  3595	
  3596	    constexpr subrange<iterator_t<_Vp>>
  3597	    _M_find_next(iterator_t<_Vp> __it)
  3598	    {
  3599	      auto [__b, __e] = ranges::search(subrange(__it, ranges::end(_M_base)), _M_pattern);
  3600	      if (__b != ranges::end(_M_base) && ranges::empty(_M_pattern))
  3601		{
  3602		  ++__b;
  3603		  ++__e;
  3604		}
  3605	      return {__b, __e};
  3606	    }
  3607	
  3608	  private:
  3609	    struct _Iterator
  3610	    {
  3611	    private:
  3612	      split_view* _M_parent = nullptr;
  3613	      iterator_t<_Vp> _M_cur = iterator_t<_Vp>();
  3614	      subrange<iterator_t<_Vp>> _M_next = subrange<iterator_t<_Vp>>();
  3615	      bool _M_trailing_empty = false;
  3616	
  3617	      friend struct _Sentinel;
  3618	
  3619	    public:
  3620	      using iterator_concept = forward_iterator_tag;
  3621	      using iterator_category = input_iterator_tag;
  3622	      using value_type = subrange<iterator_t<_Vp>>;
  3623	      using difference_type = range_difference_t<_Vp>;
  3624	
  3625	      _Iterator() = default;
  3626	
  3627	      constexpr
  3628	      _Iterator(split_view* __parent,
  3629			iterator_t<_Vp> __current,
  3630			subrange<iterator_t<_Vp>> __next)
  3631		: _M_parent(__parent),
  3632		  _M_cur(std::move(__current)),
  3633		  _M_next(std::move(__next))
  3634	      { }
  3635	
  3636	      constexpr iterator_t<_Vp>
  3637	      base() const
  3638	      { return _M_cur; }
  3639	
  3640	      constexpr value_type
  3641	      operator*() const
  3642	      { return {_M_cur, _M_next.begin()}; }
  3643	
  3644	      constexpr _Iterator&
  3645	      operator++()
  3646	      {
  3647		_M_cur = _M_next.begin();
  3648		if (_M_cur != ranges::end(_M_parent->_M_base))
  3649		  {
  3650		    _M_cur = _M_next.end();
  3651		    if (_M_cur == ranges::end(_M_parent->_M_base))
  3652		      {
  3653			_M_trailing_empty = true;
  3654			_M_next = {_M_cur, _M_cur};
  3655		      }
  3656		    else
  3657		      _M_next = _M_parent->_M_find_next(_M_cur);
  3658		  }
  3659		else
  3660		  _M_trailing_empty = false;
  3661		return *this;
  3662	      }
  3663	
  3664	      constexpr _Iterator
  3665	      operator++(int)
  3666	      {
  3667		auto __tmp = *this;
  3668		++*this;
  3669		return __tmp;
  3670	      }
  3671	
  3672	      friend constexpr bool
  3673	      operator==(const _Iterator& __x, const _Iterator& __y)
  3674	      {
  3675		return __x._M_cur == __y._M_cur
  3676		  && __x._M_trailing_empty == __y._M_trailing_empty;
  3677	      }
  3678	    };
  3679	
  3680	    struct _Sentinel
  3681	    {
  3682	    private:
  3683	      sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
  3684	
  3685	      constexpr bool
  3686	      _M_equal(const _Iterator& __x) const
  3687	      { return __x._M_cur == _M_end && !__x._M_trailing_empty; }
  3688	
  3689	    public:
  3690	      _Sentinel() = default;
  3691	
  3692	      constexpr explicit
  3693	      _Sentinel(split_view* __parent)
  3694		: _M_end(ranges::end(__parent->_M_base))
  3695	      { }
  3696	
  3697	      friend constexpr bool
  3698	      operator==(const _Iterator& __x, const _Sentinel& __y)
  3699	      { return __y._M_equal(__x); }
  3700	    };
  3701	  };
  3702	
  3703	  template<typename _Range, typename _Pattern>
  3704	    split_view(_Range&&, _Pattern&&)
  3705	      -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
  3706	
  3707	  template<forward_range _Range>
  3708	    split_view(_Range&&, range_value_t<_Range>)
  3709	      -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
  3710	
  3711	  namespace views
  3712	  {
  3713	    namespace __detail
  3714	    {
  3715	      template<typename _Range, typename _Pattern>
  3716		concept __can_split_view
  3717		  = requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
  3718	    } // namespace __detail
  3719	
  3720	    struct _Split : __adaptor::_RangeAdaptor<_Split>
  3721	    {
  3722	      template<viewable_range _Range, typename _Pattern>
  3723		requires __detail::__can_split_view<_Range, _Pattern>
  3724		constexpr auto
  3725		operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
  3726		{
  3727		  return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
  3728		}
  3729	
  3730	      using _RangeAdaptor<_Split>::operator();
  3731	      static constexpr int _S_arity = 2;
  3732	      template<typename _Pattern>
  3733		static constexpr bool _S_has_simple_extra_args
  3734		  = _LazySplit::_S_has_simple_extra_args<_Pattern>;
  3735	    };
  3736	
  3737	    inline constexpr _Split split;
  3738	  } // namespace views
  3739	
  3740	  namespace views
  3741	  {
  3742	    struct _Counted
  3743	    {
  3744	      template<input_or_output_iterator _Iter>
  3745	      constexpr auto
  3746	      operator() [[nodiscard]] (_Iter __i, iter_difference_t<_Iter> __n) const
  3747	      {
  3748		if constexpr (contiguous_iterator<_Iter>)
  3749		  return span(std::__to_address(__i), __n);
  3750		else if constexpr (random_access_iterator<_Iter>)
  3751		  return subrange(__i, __i + __n);
  3752		else
  3753		  return subrange(counted_iterator(std::move(__i), __n),
  3754				  default_sentinel);
  3755	      }
  3756	    };
  3757	
  3758	    inline constexpr _Counted counted{};
  3759	  } // namespace views
  3760	
  3761	  template<view _Vp>
  3762	    requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
  3763	    class common_view : public view_interface<common_view<_Vp>>
  3764	    {
  3765	    private:
  3766	      _Vp _M_base = _Vp();
  3767	
  3768	    public:
  3769	      common_view() requires default_initializable<_Vp> = default;
  3770	
  3771	      constexpr explicit
  3772	      common_view(_Vp __r)
  3773		: _M_base(std::move(__r))
  3774	      { }
  3775	
  3776	      constexpr _Vp
  3777	      base() const& requires copy_constructible<_Vp>
  3778	      { return _M_base; }
  3779	
  3780	      constexpr _Vp
  3781	      base() &&
  3782	      { return std::move(_M_base); }
  3783	
  3784	      constexpr auto
  3785	      begin()
  3786	      {
  3787		if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
  3788		  return ranges::begin(_M_base);
  3789		else
  3790		  return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
  3791			  (ranges::begin(_M_base));
  3792	      }
  3793	
  3794	      constexpr auto
  3795	      begin() const requires range<const _Vp>
  3796	      {
  3797		if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
  3798		  return ranges::begin(_M_base);
  3799		else
  3800		  return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
  3801			  (ranges::begin(_M_base));
  3802	      }
  3803	
  3804	      constexpr auto
  3805	      end()
  3806	      {
  3807		if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
  3808		  return ranges::begin(_M_base) + ranges::size(_M_base);
  3809		else
  3810		  return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
  3811			  (ranges::end(_M_base));
  3812	      }
  3813	
  3814	      constexpr auto
  3815	      end() const requires range<const _Vp>
  3816	      {
  3817		if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
  3818		  return ranges::begin(_M_base) + ranges::size(_M_base);
  3819		else
  3820		  return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
  3821			  (ranges::end(_M_base));
  3822	      }
  3823	
  3824	      constexpr auto
  3825	      size() requires sized_range<_Vp>
  3826	      { return ranges::size(_M_base); }
  3827	
  3828	      constexpr auto
  3829	      size() const requires sized_range<const _Vp>
  3830	      { return ranges::size(_M_base); }
  3831	    };
  3832	
  3833	  template<typename _Range>
  3834	    common_view(_Range&&) -> common_view<views::all_t<_Range>>;
  3835	
  3836	  template<typename _Tp>
  3837	    inline constexpr bool enable_borrowed_range<common_view<_Tp>>
  3838	      = enable_borrowed_range<_Tp>;
  3839	
  3840	  namespace views
  3841	  {
  3842	    namespace __detail
  3843	    {
  3844	      template<typename _Range>
  3845		concept __already_common = common_range<_Range>
  3846		  && requires { views::all(std::declval<_Range>()); };
  3847	
  3848	      template<typename _Range>
  3849		concept __can_common_view
  3850		  = requires { common_view{std::declval<_Range>()}; };
  3851	    } // namespace __detail
  3852	
  3853	    struct _Common : __adaptor::_RangeAdaptorClosure
  3854	    {
  3855	      template<viewable_range _Range>
  3856		requires __detail::__already_common<_Range>
  3857		  || __detail::__can_common_view<_Range>
  3858		constexpr auto
  3859		operator() [[nodiscard]] (_Range&& __r) const
  3860		{
  3861		  if constexpr (__detail::__already_common<_Range>)
  3862		    return views::all(std::forward<_Range>(__r));
  3863		  else
  3864		    return common_view{std::forward<_Range>(__r)};
  3865		}
  3866	
  3867	      static constexpr bool _S_has_simple_call_op = true;
  3868	    };
  3869	
  3870	    inline constexpr _Common common;
  3871	  } // namespace views
  3872	
  3873	  template<view _Vp>
  3874	    requires bidirectional_range<_Vp>
  3875	    class reverse_view : public view_interface<reverse_view<_Vp>>
  3876	    {
  3877	    private:
  3878	      static constexpr bool _S_needs_cached_begin
  3879		= !common_range<_Vp> && !(random_access_range<_Vp>
  3880					  && sized_sentinel_for<sentinel_t<_Vp>,
  3881								iterator_t<_Vp>>);
  3882	
  3883	      _Vp _M_base = _Vp();
  3884	      [[no_unique_address]]
  3885		__detail::__maybe_present_t<_S_needs_cached_begin,
  3886					    __detail::_CachedPosition<_Vp>>
  3887					      _M_cached_begin;
  3888	
  3889	    public:
  3890	      reverse_view() requires default_initializable<_Vp> = default;
  3891	
  3892	      constexpr explicit
  3893	      reverse_view(_Vp __r)
  3894		: _M_base(std::move(__r))
  3895		{ }
  3896	
  3897	      constexpr _Vp
  3898	      base() const& requires copy_constructible<_Vp>
  3899	      { return _M_base; }
  3900	
  3901	      constexpr _Vp
  3902	      base() &&
  3903	      { return std::move(_M_base); }
  3904	
  3905	      constexpr reverse_iterator<iterator_t<_Vp>>
  3906	      begin()
  3907	      {
  3908		if constexpr (_S_needs_cached_begin)
  3909		  if (_M_cached_begin._M_has_value())
  3910		    return std::make_reverse_iterator(_M_cached_begin._M_get(_M_base));
  3911	
  3912		auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base));
  3913		if constexpr (_S_needs_cached_begin)
  3914		  _M_cached_begin._M_set(_M_base, __it);
  3915		return std::make_reverse_iterator(std::move(__it));
  3916	      }
  3917	
  3918	      constexpr auto
  3919	      begin() requires common_range<_Vp>
  3920	      { return std::make_reverse_iterator(ranges::end(_M_base)); }
  3921	
  3922	      constexpr auto
  3923	      begin() const requires common_range<const _Vp>
  3924	      { return std::make_reverse_iterator(ranges::end(_M_base)); }
  3925	
  3926	      constexpr reverse_iterator<iterator_t<_Vp>>
  3927	      end()
  3928	      { return std::make_reverse_iterator(ranges::begin(_M_base)); }
  3929	
  3930	      constexpr auto
  3931	      end() const requires common_range<const _Vp>
  3932	      { return std::make_reverse_iterator(ranges::begin(_M_base)); }
  3933	
  3934	      constexpr auto
  3935	      size() requires sized_range<_Vp>
  3936	      { return ranges::size(_M_base); }
  3937	
  3938	      constexpr auto
  3939	      size() const requires sized_range<const _Vp>
  3940	      { return ranges::size(_M_base); }
  3941	    };
  3942	
  3943	  template<typename _Range>
  3944	    reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
  3945	
  3946	  template<typename _Tp>
  3947	    inline constexpr bool enable_borrowed_range<reverse_view<_Tp>>
  3948	      = enable_borrowed_range<_Tp>;
  3949	
  3950	  namespace views
  3951	  {
  3952	    namespace __detail
  3953	    {
  3954	      template<typename>
  3955		inline constexpr bool __is_reversible_subrange = false;
  3956	
  3957	      template<typename _Iter, subrange_kind _Kind>
  3958		inline constexpr bool
  3959		  __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
  3960						    reverse_iterator<_Iter>,
  3961						    _Kind>> = true;
  3962	
  3963	      template<typename>
  3964		inline constexpr bool __is_reverse_view = false;
  3965	
  3966	      template<typename _Vp>
  3967		inline constexpr bool __is_reverse_view<reverse_view<_Vp>> = true;
  3968	
  3969	      template<typename _Range>
  3970		concept __can_reverse_view
  3971		  = requires { reverse_view{std::declval<_Range>()}; };
  3972	    } // namespace __detail
  3973	
  3974	    struct _Reverse : __adaptor::_RangeAdaptorClosure
  3975	    {
  3976	      template<viewable_range _Range>
  3977		requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
  3978		  || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
  3979		  || __detail::__can_reverse_view<_Range>
  3980		constexpr auto
  3981		operator() [[nodiscard]] (_Range&& __r) const
  3982		{
  3983		  using _Tp = remove_cvref_t<_Range>;
  3984		  if constexpr (__detail::__is_reverse_view<_Tp>)
  3985		    return std::forward<_Range>(__r).base();
  3986		  else if constexpr (__detail::__is_reversible_subrange<_Tp>)
  3987		    {
  3988		      using _Iter = decltype(ranges::begin(__r).base());
  3989		      if constexpr (sized_range<_Tp>)
  3990			return subrange<_Iter, _Iter, subrange_kind::sized>
  3991				{__r.end().base(), __r.begin().base(), __r.size()};
  3992		      else
  3993			return subrange<_Iter, _Iter, subrange_kind::unsized>
  3994				{__r.end().base(), __r.begin().base()};
  3995		    }
  3996		  else
  3997		    return reverse_view{std::forward<_Range>(__r)};
  3998		}
  3999	
  4000	      static constexpr bool _S_has_simple_call_op = true;
  4001	    };
  4002	
  4003	    inline constexpr _Reverse reverse;
  4004	  } // namespace views
  4005	
  4006	  namespace __detail
  4007	  {
  4008	    template<typename _Tp, size_t _Nm>
  4009	    concept __has_tuple_element = requires(_Tp __t)
  4010	      {
  4011		typename tuple_size<_Tp>::type;
  4012		requires _Nm < tuple_size_v<_Tp>;
  4013		typename tuple_element_t<_Nm, _Tp>;
  4014		{ std::get<_Nm>(__t) }
  4015		  -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
  4016	      };
  4017	
  4018	    template<typename _Tp, size_t _Nm>
  4019	      concept __returnable_element
  4020		= is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
  4021	  }
  4022	
  4023	  template<input_range _Vp, size_t _Nm>
  4024	    requires view<_Vp>
  4025	      && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
  4026	      && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
  4027					       _Nm>
  4028	      && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
  4029	    class elements_view : public view_interface<elements_view<_Vp, _Nm>>
  4030	    {
  4031	    public:
  4032	      elements_view() requires default_initializable<_Vp> = default;
  4033	
  4034	      constexpr explicit
  4035	      elements_view(_Vp __base)
  4036		: _M_base(std::move(__base))
  4037	      { }
  4038	
  4039	      constexpr _Vp
  4040	      base() const& requires copy_constructible<_Vp>
  4041	      { return _M_base; }
  4042	
  4043	      constexpr _Vp
  4044	      base() &&
  4045	      { return std::move(_M_base); }
  4046	
  4047	      constexpr auto
  4048	      begin() requires (!__detail::__simple_view<_Vp>)
  4049	      { return _Iterator<false>(ranges::begin(_M_base)); }
  4050	
  4051	      constexpr auto
  4052	      begin() const requires range<const _Vp>
  4053	      { return _Iterator<true>(ranges::begin(_M_base)); }
  4054	
  4055	      constexpr auto
  4056	      end() requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
  4057	      { return _Sentinel<false>{ranges::end(_M_base)}; }
  4058	
  4059	      constexpr auto
  4060	      end() requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
  4061	      { return _Iterator<false>{ranges::end(_M_base)}; }
  4062	
  4063	      constexpr auto
  4064	      end() const requires range<const _Vp>
  4065	      { return _Sentinel<true>{ranges::end(_M_base)}; }
  4066	
  4067	      constexpr auto
  4068	      end() const requires common_range<const _Vp>
  4069	      { return _Iterator<true>{ranges::end(_M_base)}; }
  4070	
  4071	      constexpr auto
  4072	      size() requires sized_range<_Vp>
  4073	      { return ranges::size(_M_base); }
  4074	
  4075	      constexpr auto
  4076	      size() const requires sized_range<const _Vp>
  4077	      { return ranges::size(_M_base); }
  4078	
  4079	    private:
  4080	      template<bool _Const>
  4081		using _Base = __detail::__maybe_const_t<_Const, _Vp>;
  4082	
  4083	      template<bool _Const>
  4084		struct __iter_cat
  4085		{ };
  4086	
  4087	      template<bool _Const>
  4088		requires forward_range<_Base<_Const>>
  4089		struct __iter_cat<_Const>
  4090		{
  4091		private:
  4092		  static auto _S_iter_cat()
  4093		  {
  4094		    using _Base = elements_view::_Base<_Const>;
  4095		    using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
  4096		    using _Res = decltype((std::get<_Nm>(*std::declval<iterator_t<_Base>>())));
  4097		    if constexpr (!is_lvalue_reference_v<_Res>)
  4098		      return input_iterator_tag{};
  4099		    else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
  4100		      return random_access_iterator_tag{};
  4101		    else
  4102		      return _Cat{};
  4103		  }
  4104		public:
  4105		  using iterator_category = decltype(_S_iter_cat());
  4106		};
  4107	
  4108	      template<bool _Const>
  4109		struct _Sentinel;
  4110	
  4111	      template<bool _Const>
  4112		struct _Iterator : __iter_cat<_Const>
  4113		{
  4114		private:
  4115		  using _Base = elements_view::_Base<_Const>;
  4116	
  4117		  iterator_t<_Base> _M_current = iterator_t<_Base>();
  4118	
  4119		  static constexpr decltype(auto)
  4120		  _S_get_element(const iterator_t<_Base>& __i)
  4121		  {
  4122		    if constexpr (is_reference_v<range_reference_t<_Base>>)
  4123		      return std::get<_Nm>(*__i);
  4124		    else
  4125		      {
  4126			using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
  4127			return static_cast<_Et>(std::get<_Nm>(*__i));
  4128		      }
  4129		  }
  4130	
  4131		  static auto
  4132		  _S_iter_concept()
  4133		  {
  4134		    if constexpr (random_access_range<_Base>)
  4135		      return random_access_iterator_tag{};
  4136		    else if constexpr (bidirectional_range<_Base>)
  4137		      return bidirectional_iterator_tag{};
  4138		    else if constexpr (forward_range<_Base>)
  4139		      return forward_iterator_tag{};
  4140		    else
  4141		      return input_iterator_tag{};
  4142		  }
  4143	
  4144		  friend _Iterator<!_Const>;
  4145	
  4146		public:
  4147		  using iterator_concept = decltype(_S_iter_concept());
  4148		  // iterator_category defined in elements_view::__iter_cat
  4149		  using value_type
  4150		    = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
  4151		  using difference_type = range_difference_t<_Base>;
  4152	
  4153		  _Iterator() requires default_initializable<iterator_t<_Base>> = default;
  4154	
  4155		  constexpr explicit
  4156		  _Iterator(iterator_t<_Base> __current)
  4157		    : _M_current(std::move(__current))
  4158		  { }
  4159	
  4160		  constexpr
  4161		  _Iterator(_Iterator<!_Const> __i)
  4162		    requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
  4163		    : _M_current(std::move(__i._M_current))
  4164		  { }
  4165	
  4166		  constexpr const iterator_t<_Base>&
  4167		  base() const& noexcept
  4168		  { return _M_current; }
  4169	
  4170		  constexpr iterator_t<_Base>
  4171		  base() &&
  4172		  { return std::move(_M_current); }
  4173	
  4174		  constexpr decltype(auto)
  4175		  operator*() const
  4176		  { return _S_get_element(_M_current); }
  4177	
  4178		  constexpr _Iterator&
  4179		  operator++()
  4180		  {
  4181		    ++_M_current;
  4182		    return *this;
  4183		  }
  4184	
  4185		  constexpr void
  4186		  operator++(int)
  4187		  { ++_M_current; }
  4188	
  4189		  constexpr _Iterator
  4190		  operator++(int) requires forward_range<_Base>
  4191		  {
  4192		    auto __tmp = *this;
  4193		    ++_M_current;
  4194		    return __tmp;
  4195		  }
  4196	
  4197		  constexpr _Iterator&
  4198		  operator--() requires bidirectional_range<_Base>
  4199		  {
  4200		    --_M_current;
  4201		    return *this;
  4202		  }
  4203	
  4204		  constexpr _Iterator
  4205		  operator--(int) requires bidirectional_range<_Base>
  4206		  {
  4207		    auto __tmp = *this;
  4208		    --_M_current;
  4209		    return __tmp;
  4210		  }
  4211	
  4212		  constexpr _Iterator&
  4213		  operator+=(difference_type __n)
  4214		    requires random_access_range<_Base>
  4215		  {
  4216		    _M_current += __n;
  4217		    return *this;
  4218		  }
  4219	
  4220		  constexpr _Iterator&
  4221		  operator-=(difference_type __n)
  4222		    requires random_access_range<_Base>
  4223		  {
  4224		    _M_current -= __n;
  4225		    return *this;
  4226		  }
  4227	
  4228		  constexpr decltype(auto)
  4229		  operator[](difference_type __n) const
  4230		    requires random_access_range<_Base>
  4231		  { return _S_get_element(_M_current + __n); }
  4232	
  4233		  friend constexpr bool
  4234		  operator==(const _Iterator& __x, const _Iterator& __y)
  4235		    requires equality_comparable<iterator_t<_Base>>
  4236		  { return __x._M_current == __y._M_current; }
  4237	
  4238		  friend constexpr bool
  4239		  operator<(const _Iterator& __x, const _Iterator& __y)
  4240		    requires random_access_range<_Base>
  4241		  { return __x._M_current < __y._M_current; }
  4242	
  4243		  friend constexpr bool
  4244		  operator>(const _Iterator& __x, const _Iterator& __y)
  4245		    requires random_access_range<_Base>
  4246		  { return __y._M_current < __x._M_current; }
  4247	
  4248		  friend constexpr bool
  4249		  operator<=(const _Iterator& __x, const _Iterator& __y)
  4250		    requires random_access_range<_Base>
  4251		  { return !(__y._M_current > __x._M_current); }
  4252	
  4253		  friend constexpr bool
  4254		  operator>=(const _Iterator& __x, const _Iterator& __y)
  4255		    requires random_access_range<_Base>
  4256		  { return !(__x._M_current > __y._M_current); }
  4257	
  4258	#ifdef __cpp_lib_three_way_comparison
  4259		  friend constexpr auto
  4260		  operator<=>(const _Iterator& __x, const _Iterator& __y)
  4261		    requires random_access_range<_Base>
  4262		      && three_way_comparable<iterator_t<_Base>>
  4263		  { return __x._M_current <=> __y._M_current; }
  4264	#endif
  4265	
  4266		  friend constexpr _Iterator
  4267		  operator+(const _Iterator& __x, difference_type __y)
  4268		    requires random_access_range<_Base>
  4269		  { return _Iterator{__x} += __y; }
  4270	
  4271		  friend constexpr _Iterator
  4272		  operator+(difference_type __x, const _Iterator& __y)
  4273		    requires random_access_range<_Base>
  4274		  { return __y + __x; }
  4275	
  4276		  friend constexpr _Iterator
  4277		  operator-(const _Iterator& __x, difference_type __y)
  4278		    requires random_access_range<_Base>
  4279		  { return _Iterator{__x} -= __y; }
  4280	
  4281		  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  4282		  // 3483. transform_view::iterator's difference is overconstrained
  4283		  friend constexpr difference_type
  4284		  operator-(const _Iterator& __x, const _Iterator& __y)
  4285		    requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
  4286		  { return __x._M_current - __y._M_current; }
  4287	
  4288		  template <bool> friend struct _Sentinel;
  4289		};
  4290	
  4291	      template<bool _Const>
  4292		struct _Sentinel
  4293		{
  4294		private:
  4295		  template<bool _Const2>
  4296		    constexpr bool
  4297		    _M_equal(const _Iterator<_Const2>& __x) const
  4298		    { return __x._M_current == _M_end; }
  4299	
  4300		  template<bool _Const2>
  4301		    constexpr auto
  4302		    _M_distance_from(const _Iterator<_Const2>& __i) const
  4303		    { return _M_end - __i._M_current; }
  4304	
  4305		  using _Base = elements_view::_Base<_Const>;
  4306		  sentinel_t<_Base> _M_end = sentinel_t<_Base>();
  4307	
  4308		public:
  4309		  _Sentinel() = default;
  4310	
  4311		  constexpr explicit
  4312		  _Sentinel(sentinel_t<_Base> __end)
  4313		    : _M_end(std::move(__end))
  4314		  { }
  4315	
  4316		  constexpr
  4317		  _Sentinel(_Sentinel<!_Const> __other)
  4318		    requires _Const
  4319		      && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
  4320		    : _M_end(std::move(__other._M_end))
  4321		  { }
  4322	
  4323		  constexpr sentinel_t<_Base>
  4324		  base() const
  4325		  { return _M_end; }
  4326	
  4327		  template<bool _Const2>
  4328		    requires sentinel_for<sentinel_t<_Base>,
  4329			       iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
  4330		    friend constexpr bool
  4331		    operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
  4332		    { return __y._M_equal(__x); }
  4333	
  4334		  template<bool _Const2,
  4335			   typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
  4336		    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
  4337		    friend constexpr range_difference_t<_Base2>
  4338		    operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
  4339		    { return -__y._M_distance_from(__x); }
  4340	
  4341		  template<bool _Const2,
  4342			   typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
  4343		    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
  4344		    friend constexpr range_difference_t<_Base2>
  4345		    operator-(const _Sentinel& __x, const _Iterator<_Const2>& __y)
  4346		    { return __x._M_distance_from(__y); }
  4347	
  4348		  friend _Sentinel<!_Const>;
  4349		};
  4350	
  4351	      _Vp _M_base = _Vp();
  4352	    };
  4353	
  4354	  template<typename _Tp, size_t _Nm>
  4355	    inline constexpr bool enable_borrowed_range<elements_view<_Tp, _Nm>>
  4356	      = enable_borrowed_range<_Tp>;
  4357	
  4358	  template<typename _Range>
  4359	    using keys_view = elements_view<views::all_t<_Range>, 0>;
  4360	
  4361	  template<typename _Range>
  4362	    using values_view = elements_view<views::all_t<_Range>, 1>;
  4363	
  4364	  namespace views
  4365	  {
  4366	    namespace __detail
  4367	    {
  4368	      template<size_t _Nm, typename _Range>
  4369		concept __can_elements_view
  4370		  = requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
  4371	    } // namespace __detail
  4372	
  4373	    template<size_t _Nm>
  4374	      struct _Elements : __adaptor::_RangeAdaptorClosure
  4375	      {
  4376		template<viewable_range _Range>
  4377		  requires __detail::__can_elements_view<_Nm, _Range>
  4378		  constexpr auto
  4379		  operator() [[nodiscard]] (_Range&& __r) const
  4380		  {
  4381		    return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
  4382		  }
  4383	
  4384		static constexpr bool _S_has_simple_call_op = true;
  4385	      };
  4386	
  4387	    template<size_t _Nm>
  4388	      inline constexpr _Elements<_Nm> elements;
  4389	    inline constexpr auto keys = elements<0>;
  4390	    inline constexpr auto values = elements<1>;
  4391	  } // namespace views
  4392	
  4393	#if __cplusplus > 202002L
  4394	
  4395	#define __cpp_lib_ranges_zip 202110L
  4396	
  4397	  namespace __detail
  4398	  {
  4399	    template<typename... _Rs>
  4400	      concept __zip_is_common = (sizeof...(_Rs) == 1 && (common_range<_Rs> && ...))
  4401		|| (!(bidirectional_range<_Rs> && ...) && (common_range<_Rs> && ...))
  4402		|| ((random_access_range<_Rs> && ...) && (sized_range<_Rs> && ...));
  4403	
  4404	    template<typename... _Ts>
  4405	      struct __tuple_or_pair
  4406	      { using type = std::tuple<_Ts...>; };
  4407	
  4408	    template<typename _Tp, typename _Up>
  4409	      struct __tuple_or_pair<_Tp, _Up>
  4410	      { using type = pair<_Tp, _Up>; };
  4411	
  4412	    template<typename... _Ts>
  4413	      using __tuple_or_pair_t = typename __tuple_or_pair<_Ts...>::type;
  4414	
  4415	    template<typename _Fp, typename _Tuple>
  4416	      constexpr auto
  4417	      __tuple_transform(_Fp&& __f, _Tuple&& __tuple)
  4418	      {
  4419		return std::apply([&]<typename... _Ts>(_Ts&&... __elts) {
  4420		  return __tuple_or_pair_t<invoke_result_t<_Fp&, _Ts>...>
  4421		    (std::__invoke(__f, std::forward<_Ts>(__elts))...);
  4422		}, std::forward<_Tuple>(__tuple));
  4423	      }
  4424	
  4425	    template<typename _Fp, typename _Tuple>
  4426	      constexpr void
  4427	      __tuple_for_each(_Fp&& __f, _Tuple&& __tuple)
  4428	      {
  4429		std::apply([&]<typename... _Ts>(_Ts&&... __elts) {
  4430		  (std::__invoke(__f, std::forward<_Ts>(__elts)), ...);
  4431		}, std::forward<_Tuple>(__tuple));
  4432	      }
  4433	  } // namespace __detail
  4434	
  4435	  template<input_range... _Vs>
  4436	    requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
  4437	  class zip_view : public view_interface<zip_view<_Vs...>>
  4438	  {
  4439	    tuple<_Vs...> _M_views;
  4440	
  4441	    template<bool> class _Iterator;
  4442	    template<bool> class _Sentinel;
  4443	
  4444	  public:
  4445	    zip_view() = default;
  4446	
  4447	    constexpr explicit
  4448	    zip_view(_Vs... __views)
  4449	      : _M_views(std::move(__views)...)
  4450	    { }
  4451	
  4452	    constexpr auto
  4453	    begin() requires (!(__detail::__simple_view<_Vs> && ...))
  4454	    { return _Iterator<false>(__detail::__tuple_transform(ranges::begin, _M_views)); }
  4455	
  4456	    constexpr auto
  4457	    begin() const requires (range<const _Vs> && ...)
  4458	    { return _Iterator<true>(__detail::__tuple_transform(ranges::begin, _M_views)); }
  4459	
  4460	    constexpr auto
  4461	    end() requires (!(__detail::__simple_view<_Vs> && ...))
  4462	    {
  4463	      if constexpr (!__detail::__zip_is_common<_Vs...>)
  4464	        return _Sentinel<false>(__detail::__tuple_transform(ranges::end, _M_views));
  4465	      else if constexpr ((random_access_range<_Vs> && ...))
  4466	        return begin() + iter_difference_t<_Iterator<false>>(size());
  4467	      else
  4468	        return _Iterator<false>(__detail::__tuple_transform(ranges::end, _M_views));
  4469	    }
  4470	
  4471	    constexpr auto
  4472	    end() const requires (range<const _Vs> && ...)
  4473	    {
  4474	      if constexpr (!__detail::__zip_is_common<const _Vs...>)
  4475	        return _Sentinel<true>(__detail::__tuple_transform(ranges::end, _M_views));
  4476	      else if constexpr ((random_access_range<const _Vs> && ...))
  4477	        return begin() + iter_difference_t<_Iterator<true>>(size());
  4478	      else
  4479	        return _Iterator<true>(__detail::__tuple_transform(ranges::end, _M_views));
  4480	    }
  4481	
  4482	    constexpr auto
  4483	    size() requires (sized_range<_Vs> && ...)
  4484	    {
  4485	      return std::apply([](auto... sizes) {
  4486		using _CT = __detail::__make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
  4487		return ranges::min({_CT(sizes)...});
  4488	      }, __detail::__tuple_transform(ranges::size, _M_views));
  4489	    }
  4490	
  4491	    constexpr auto
  4492	    size() const requires (sized_range<const _Vs> && ...)
  4493	    {
  4494	      return std::apply([](auto... sizes) {
  4495		using _CT = __detail::__make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
  4496		return ranges::min({_CT(sizes)...});
  4497	      }, __detail::__tuple_transform(ranges::size, _M_views));
  4498	    }
  4499	  };
  4500	
  4501	  template<typename... _Rs>
  4502	    zip_view(_Rs&&...) -> zip_view<views::all_t<_Rs>...>;
  4503	
  4504	  template<typename... _Views>
  4505	    inline constexpr bool enable_borrowed_range<zip_view<_Views...>>
  4506	      = (enable_borrowed_range<_Views> && ...);
  4507	
  4508	  namespace __detail
  4509	  {
  4510	    template<bool _Const, typename... _Vs>
  4511	      concept __all_random_access
  4512		= (random_access_range<__maybe_const_t<_Const, _Vs>> && ...);
  4513	
  4514	    template<bool _Const, typename... _Vs>
  4515	      concept __all_bidirectional
  4516		= (bidirectional_range<__maybe_const_t<_Const, _Vs>> && ...);
  4517	
  4518	    template<bool _Const, typename... _Vs>
  4519	      concept __all_forward
  4520		= (forward_range<__maybe_const_t<_Const, _Vs>> && ...);
  4521	
  4522	    template<bool _Const, typename... _Views>
  4523	      struct __zip_view_iter_cat
  4524	      { };
  4525	
  4526	    template<bool _Const, typename... _Views>
  4527	      requires __all_forward<_Const, _Views...>
  4528	      struct __zip_view_iter_cat<_Const, _Views...>
  4529	      { using iterator_category = input_iterator_tag; };
  4530	  } // namespace __detail
  4531	
  4532	  template<input_range... _Vs>
  4533	    requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
  4534	  template<bool _Const>
  4535	  class zip_view<_Vs...>::_Iterator
  4536	    : public __detail::__zip_view_iter_cat<_Const, _Vs...>
  4537	  {
  4538	#ifdef __clang__ // LLVM-61763 workaround
  4539	  public:
  4540	#endif
  4541	    __detail::__tuple_or_pair_t<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_current;
  4542	
  4543	    constexpr explicit
  4544	    _Iterator(decltype(_M_current) __current)
  4545	      : _M_current(std::move(__current))
  4546	    { }
  4547	
  4548	    static auto
  4549	    _S_iter_concept()
  4550	    {
  4551	      if constexpr (__detail::__all_random_access<_Const, _Vs...>)
  4552		return random_access_iterator_tag{};
  4553	      else if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
  4554		return bidirectional_iterator_tag{};
  4555	      else if constexpr (__detail::__all_forward<_Const, _Vs...>)
  4556		return forward_iterator_tag{};
  4557	      else
  4558		return input_iterator_tag{};
  4559	    }
  4560	
  4561	#ifndef __clang__ // LLVM-61763 workaround
  4562	    template<copy_constructible _Fp, input_range... _Ws>
  4563	      requires (view<_Ws> && ...) && (sizeof...(_Ws) > 0) && is_object_v<_Fp>
  4564		&& regular_invocable<_Fp&, range_reference_t<_Ws>...>
  4565		&& std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Ws>...>>
  4566	      friend class zip_transform_view;
  4567	#endif
  4568	
  4569	  public:
  4570	    // iterator_category defined in __zip_view_iter_cat
  4571	    using iterator_concept = decltype(_S_iter_concept());
  4572	    using value_type
  4573	      = __detail::__tuple_or_pair_t<range_value_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
  4574	    using difference_type
  4575	      = common_type_t<range_difference_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
  4576	
  4577	    _Iterator() = default;
  4578	
  4579	    constexpr
  4580	    _Iterator(_Iterator<!_Const> __i)
  4581	      requires _Const
  4582		&& (convertible_to<iterator_t<_Vs>,
  4583				   iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
  4584	      : _M_current(std::move(__i._M_current))
  4585	    { }
  4586	
  4587	    constexpr auto
  4588	    operator*() const
  4589	    {
  4590	      auto __f = [](auto& __i) -> decltype(auto) {
  4591		return *__i;
  4592	      };
  4593	      return __detail::__tuple_transform(__f, _M_current);
  4594	    }
  4595	
  4596	    constexpr _Iterator&
  4597	    operator++()
  4598	    {
  4599	      __detail::__tuple_for_each([](auto& __i) { ++__i; }, _M_current);
  4600	      return *this;
  4601	    }
  4602	
  4603	    constexpr void
  4604	    operator++(int)
  4605	    { ++*this; }
  4606	
  4607	    constexpr _Iterator
  4608	    operator++(int)
  4609	      requires __detail::__all_forward<_Const, _Vs...>
  4610	    {
  4611	      auto __tmp = *this;
  4612	      ++*this;
  4613	      return __tmp;
  4614	    }
  4615	
  4616	    constexpr _Iterator&
  4617	    operator--()
  4618	      requires __detail::__all_bidirectional<_Const, _Vs...>
  4619	    {
  4620	      __detail::__tuple_for_each([](auto& __i) { --__i; }, _M_current);
  4621	      return *this;
  4622	    }
  4623	
  4624	    constexpr _Iterator
  4625	    operator--(int)
  4626	      requires __detail::__all_bidirectional<_Const, _Vs...>
  4627	    {
  4628	      auto __tmp = *this;
  4629	      --*this;
  4630	      return __tmp;
  4631	    }
  4632	
  4633	    constexpr _Iterator&
  4634	    operator+=(difference_type __x)
  4635	      requires __detail::__all_random_access<_Const, _Vs...>
  4636	    {
  4637	      auto __f = [&]<typename _It>(_It& __i) {
  4638		__i += iter_difference_t<_It>(__x);
  4639	      };
  4640	      __detail::__tuple_for_each(__f, _M_current);
  4641	      return *this;
  4642	    }
  4643	
  4644	    constexpr _Iterator&
  4645	    operator-=(difference_type __x)
  4646	      requires __detail::__all_random_access<_Const, _Vs...>
  4647	    {
  4648	      auto __f = [&]<typename _It>(_It& __i) {
  4649		__i -= iter_difference_t<_It>(__x);
  4650	      };
  4651	      __detail::__tuple_for_each(__f, _M_current);
  4652	      return *this;
  4653	    }
  4654	
  4655	    constexpr auto
  4656	    operator[](difference_type __n) const
  4657	      requires __detail::__all_random_access<_Const, _Vs...>
  4658	    {
  4659	      auto __f = [&]<typename _It>(_It& __i) -> decltype(auto) {
  4660		return __i[iter_difference_t<_It>(__n)];
  4661	      };
  4662	      return __detail::__tuple_transform(__f, _M_current);
  4663	    }
  4664	
  4665	    friend constexpr bool
  4666	    operator==(const _Iterator& __x, const _Iterator& __y)
  4667	      requires (equality_comparable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
  4668	    {
  4669	      if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
  4670		return __x._M_current == __y._M_current;
  4671	      else
  4672		return [&]<size_t... _Is>(index_sequence<_Is...>) {
  4673		  return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_current)) || ...);
  4674		}(make_index_sequence<sizeof...(_Vs)>{});
  4675	    }
  4676	
  4677	    friend constexpr auto
  4678	    operator<=>(const _Iterator& __x, const _Iterator& __y)
  4679	      requires __detail::__all_random_access<_Const, _Vs...>
  4680	    { return __x._M_current <=> __y._M_current; }
  4681	
  4682	    friend constexpr _Iterator
  4683	    operator+(const _Iterator& __i, difference_type __n)
  4684	      requires __detail::__all_random_access<_Const, _Vs...>
  4685	    {
  4686	      auto __r = __i;
  4687	      __r += __n;
  4688	      return __r;
  4689	    }
  4690	
  4691	    friend constexpr _Iterator
  4692	    operator+(difference_type __n, const _Iterator& __i)
  4693	      requires __detail::__all_random_access<_Const, _Vs...>
  4694	    {
  4695	      auto __r = __i;
  4696	      __r += __n;
  4697	      return __r;
  4698	    }
  4699	
  4700	    friend constexpr _Iterator
  4701	    operator-(const _Iterator& __i, difference_type __n)
  4702	      requires __detail::__all_random_access<_Const, _Vs...>
  4703	    {
  4704	      auto __r = __i;
  4705	      __r -= __n;
  4706	      return __r;
  4707	    }
  4708	
  4709	    friend constexpr difference_type
  4710	    operator-(const _Iterator& __x, const _Iterator& __y)
  4711	      requires (sized_sentinel_for<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>,
  4712					   iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
  4713	    {
  4714	      return [&]<size_t... _Is>(index_sequence<_Is...>) {
  4715		return ranges::min({difference_type(std::get<_Is>(__x._M_current)
  4716						    - std::get<_Is>(__y._M_current))...},
  4717				   ranges::less{},
  4718				   [](difference_type __i) {
  4719				     return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
  4720				   });
  4721	      }(make_index_sequence<sizeof...(_Vs)>{});
  4722	    }
  4723	
  4724	    friend constexpr auto
  4725	    iter_move(const _Iterator& __i)
  4726	    { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
  4727	
  4728	    friend constexpr void
  4729	    iter_swap(const _Iterator& __l, const _Iterator& __r)
  4730	      requires (indirectly_swappable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
  4731	    {
  4732	      [&]<size_t... _Is>(index_sequence<_Is...>) {
  4733		(ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
  4734	      }(make_index_sequence<sizeof...(_Vs)>{});
  4735	    }
  4736	
  4737	    friend class zip_view;
  4738	  };
  4739	
  4740	  template<input_range... _Vs>
  4741	    requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
  4742	  template<bool _Const>
  4743	  class zip_view<_Vs...>::_Sentinel
  4744	  {
  4745	    __detail::__tuple_or_pair_t<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_end;
  4746	
  4747	    constexpr explicit
  4748	    _Sentinel(decltype(_M_end) __end)
  4749	      : _M_end(__end)
  4750	    { }
  4751	
  4752	    friend class zip_view;
  4753	
  4754	  public:
  4755	    _Sentinel() = default;
  4756	
  4757	    constexpr
  4758	    _Sentinel(_Sentinel<!_Const> __i)
  4759	      requires _Const
  4760		&& (convertible_to<sentinel_t<_Vs>,
  4761				   sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
  4762	      : _M_end(std::move(__i._M_end))
  4763	    { }
  4764	
  4765	    template<bool _OtherConst>
  4766	      requires (sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
  4767				     iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
  4768	    friend constexpr bool
  4769	    operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
  4770	    {
  4771	      return [&]<size_t... _Is>(index_sequence<_Is...>) {
  4772		return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_end)) || ...);
  4773	      }(make_index_sequence<sizeof...(_Vs)>{});
  4774	    }
  4775	
  4776	    template<bool _OtherConst>
  4777	      requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
  4778					   iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
  4779	    friend constexpr auto
  4780	    operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
  4781	    {
  4782	      using _Ret
  4783		= common_type_t<range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vs>>...>;
  4784	      return [&]<size_t... _Is>(index_sequence<_Is...>) {
  4785		return ranges::min({_Ret(std::get<_Is>(__x._M_current) - std::get<_Is>(__y._M_end))...},
  4786				   ranges::less{},
  4787				   [](_Ret __i) {
  4788				     return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
  4789				   });
  4790	      }(make_index_sequence<sizeof...(_Vs)>{});
  4791	    }
  4792	
  4793	    template<bool _OtherConst>
  4794	      requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
  4795					   iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
  4796	    friend constexpr auto
  4797	    operator-(const _Sentinel& __y, const _Iterator<_OtherConst>& __x)
  4798	    { return -(__x - __y); }
  4799	  };
  4800	
  4801	  namespace views
  4802	  {
  4803	    namespace __detail
  4804	    {
  4805	      template<typename... _Ts>
  4806		concept __can_zip_view
  4807		  = requires { zip_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
  4808	    }
  4809	
  4810	    struct _Zip
  4811	    {
  4812	      template<typename... _Ts>
  4813		requires (sizeof...(_Ts) == 0 || __detail::__can_zip_view<_Ts...>)
  4814		constexpr auto
  4815		operator() [[nodiscard]] (_Ts&&... __ts) const
  4816		{
  4817		  if constexpr (sizeof...(_Ts) == 0)
  4818		    return views::empty<tuple<>>;
  4819		  else
  4820		    return zip_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
  4821		}
  4822	    };
  4823	
  4824	    inline constexpr _Zip zip;
  4825	  }
  4826	
  4827	  namespace __detail
  4828	  {
  4829	    template<typename _Range, bool _Const>
  4830	      using __range_iter_cat
  4831		= typename iterator_traits<iterator_t<__maybe_const_t<_Const, _Range>>>::iterator_category;
  4832	  }
  4833	
  4834	  template<copy_constructible _Fp, input_range... _Vs>
  4835	    requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && is_object_v<_Fp>
  4836	      && regular_invocable<_Fp&, range_reference_t<_Vs>...>
  4837	      && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
  4838	  class zip_transform_view : public view_interface<zip_transform_view<_Fp, _Vs...>>
  4839	  {
  4840	    [[no_unique_address]] __detail::__box<_Fp> _M_fun;
  4841	    zip_view<_Vs...> _M_zip;
  4842	
  4843	    using _InnerView = zip_view<_Vs...>;
  4844	
  4845	    template<bool _Const>
  4846	      using __ziperator = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
  4847	
  4848	    template<bool _Const>
  4849	      using __zentinel = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
  4850	
  4851	    template<bool _Const>
  4852	      using _Base = __detail::__maybe_const_t<_Const, _InnerView>;
  4853	
  4854	    template<bool _Const>
  4855	      struct __iter_cat
  4856	      { };
  4857	
  4858	    template<bool _Const>
  4859	      requires forward_range<_Base<_Const>>
  4860	      struct __iter_cat<_Const>
  4861	      {
  4862	      private:
  4863		static auto
  4864		_S_iter_cat()
  4865		{
  4866		  using __detail::__maybe_const_t;
  4867		  using __detail::__range_iter_cat;
  4868		  using _Res = invoke_result_t<__maybe_const_t<_Const, _Fp>&,
  4869					       range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
  4870		  if constexpr (!is_lvalue_reference_v<_Res>)
  4871		    return input_iterator_tag{};
  4872		  else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
  4873						   random_access_iterator_tag> && ...))
  4874		    return random_access_iterator_tag{};
  4875		  else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
  4876						   bidirectional_iterator_tag> && ...))
  4877		    return bidirectional_iterator_tag{};
  4878		  else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
  4879						   forward_iterator_tag> && ...))
  4880		    return forward_iterator_tag{};
  4881		  else
  4882		    return input_iterator_tag{};
  4883		}
  4884	      public:
  4885		using iterator_category = decltype(_S_iter_cat());
  4886	      };
  4887	
  4888	    template<bool> class _Iterator;
  4889	    template<bool> class _Sentinel;
  4890	
  4891	  public:
  4892	    zip_transform_view() = default;
  4893	
  4894	    constexpr explicit
  4895	    zip_transform_view(_Fp __fun, _Vs... __views)
  4896	      : _M_fun(std::move(__fun)), _M_zip(std::move(__views)...)
  4897	    { }
  4898	
  4899	    constexpr auto
  4900	    begin()
  4901	    { return _Iterator<false>(*this, _M_zip.begin()); }
  4902	
  4903	    constexpr auto
  4904	    begin() const
  4905	      requires range<const _InnerView>
  4906		&& regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
  4907	    { return _Iterator<true>(*this, _M_zip.begin()); }
  4908	
  4909	    constexpr auto
  4910	    end()
  4911	    {
  4912	      if constexpr (common_range<_InnerView>)
  4913		return _Iterator<false>(*this, _M_zip.end());
  4914	      else
  4915		return _Sentinel<false>(_M_zip.end());
  4916	    }
  4917	
  4918	    constexpr auto
  4919	    end() const
  4920	      requires range<const _InnerView>
  4921		&& regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
  4922	    {
  4923	      if constexpr (common_range<const _InnerView>)
  4924		return _Iterator<true>(*this, _M_zip.end());
  4925	      else
  4926		return _Sentinel<true>(_M_zip.end());
  4927	    }
  4928	
  4929	    constexpr auto
  4930	    size() requires sized_range<_InnerView>
  4931	    { return _M_zip.size(); }
  4932	
  4933	    constexpr auto
  4934	    size() const requires sized_range<const _InnerView>
  4935	    { return _M_zip.size(); }
  4936	  };
  4937	
  4938	  template<class _Fp, class... Rs>
  4939	    zip_transform_view(_Fp, Rs&&...) -> zip_transform_view<_Fp, views::all_t<Rs>...>;
  4940	
  4941	  template<copy_constructible _Fp, input_range... _Vs>
  4942	    requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && is_object_v<_Fp>
  4943	      && regular_invocable<_Fp&, range_reference_t<_Vs>...>
  4944	      && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
  4945	  template<bool _Const>
  4946	  class zip_transform_view<_Fp, _Vs...>::_Iterator : public __iter_cat<_Const>
  4947	  {
  4948	    using _Parent = __detail::__maybe_const_t<_Const, zip_transform_view>;
  4949	
  4950	    _Parent* _M_parent = nullptr;
  4951	    __ziperator<_Const> _M_inner;
  4952	
  4953	    constexpr
  4954	    _Iterator(_Parent& __parent, __ziperator<_Const> __inner)
  4955	      : _M_parent(std::__addressof(__parent)), _M_inner(std::move(__inner))
  4956	    { }
  4957	
  4958	    friend class zip_transform_view;
  4959	
  4960	  public:
  4961	    // iterator_category defined in zip_transform_view::__iter_cat
  4962	    using iterator_concept = typename __ziperator<_Const>::iterator_concept;
  4963	    using value_type
  4964	      = remove_cvref_t<invoke_result_t<__detail::__maybe_const_t<_Const, _Fp>&,
  4965					       range_reference_t<__detail::__maybe_const_t<_Const, _Vs>>...>>;
  4966	    using difference_type = range_difference_t<_Base<_Const>>;
  4967	
  4968	    _Iterator() = default;
  4969	
  4970	    constexpr
  4971	    _Iterator(_Iterator<!_Const> __i)
  4972	      requires _Const && convertible_to<__ziperator<false>, __ziperator<_Const>>
  4973	      : _M_parent(__i._M_parent), _M_inner(std::move(__i._M_inner))
  4974	    { }
  4975	
  4976	    constexpr decltype(auto)
  4977	    operator*() const
  4978	    {
  4979	      return std::apply([&](const auto&... __iters) -> decltype(auto) {
  4980	        return std::__invoke(*_M_parent->_M_fun, *__iters...);
  4981	      }, _M_inner._M_current);
  4982	    }
  4983	
  4984	    constexpr _Iterator&
  4985	    operator++()
  4986	    {
  4987	      ++_M_inner;
  4988	      return *this;
  4989	    }
  4990	
  4991	    constexpr void
  4992	    operator++(int)
  4993	    { ++*this; }
  4994	
  4995	    constexpr _Iterator
  4996	    operator++(int) requires forward_range<_Base<_Const>>
  4997	    {
  4998	      auto __tmp = *this;
  4999	      ++*this;
  5000	      return __tmp;
  5001	    }
  5002	
  5003	    constexpr _Iterator&
  5004	    operator--() requires bidirectional_range<_Base<_Const>>
  5005	    {
  5006	      --_M_inner;
  5007	      return *this;
  5008	    }
  5009	
  5010	    constexpr _Iterator
  5011	    operator--(int) requires bidirectional_range<_Base<_Const>>
  5012	    {
  5013	      auto __tmp = *this;
  5014	      --*this;
  5015	      return __tmp;
  5016	    }
  5017	
  5018	    constexpr _Iterator&
  5019	    operator+=(difference_type __x) requires random_access_range<_Base<_Const>>
  5020	    {
  5021	      _M_inner += __x;
  5022	      return *this;
  5023	    }
  5024	
  5025	    constexpr _Iterator&
  5026	    operator-=(difference_type __x) requires random_access_range<_Base<_Const>>
  5027	    {
  5028	      _M_inner -= __x;
  5029	      return *this;
  5030	    }
  5031	
  5032	    constexpr decltype(auto)
  5033	    operator[](difference_type __n) const requires random_access_range<_Base<_Const>>
  5034	    {
  5035	      return std::apply([&]<typename... _Is>(const _Is&... __iters) -> decltype(auto) {
  5036	        return std::__invoke(*_M_parent->_M_fun, __iters[iter_difference_t<_Is>(__n)]...);
  5037	      }, _M_inner._M_current);
  5038	    }
  5039	
  5040	    friend constexpr bool
  5041	    operator==(const _Iterator& __x, const _Iterator& __y)
  5042	      requires equality_comparable<__ziperator<_Const>>
  5043	    { return __x._M_inner == __y._M_inner; }
  5044	
  5045	    friend constexpr auto
  5046	    operator<=>(const _Iterator& __x, const _Iterator& __y)
  5047	      requires random_access_range<_Base<_Const>>
  5048	    { return __x._M_inner <=> __y._M_inner; }
  5049	
  5050	    friend constexpr _Iterator
  5051	    operator+(const _Iterator& __i, difference_type __n)
  5052	      requires random_access_range<_Base<_Const>>
  5053	    { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
  5054	
  5055	    friend constexpr _Iterator
  5056	    operator+(difference_type __n, const _Iterator& __i)
  5057	      requires random_access_range<_Base<_Const>>
  5058	    { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
  5059	
  5060	    friend constexpr _Iterator
  5061	    operator-(const _Iterator& __i, difference_type __n)
  5062	      requires random_access_range<_Base<_Const>>
  5063	    { return _Iterator(*__i._M_parent, __i._M_inner - __n); }
  5064	
  5065	    friend constexpr difference_type
  5066	    operator-(const _Iterator& __x, const _Iterator& __y)
  5067	      requires sized_sentinel_for<__ziperator<_Const>, __ziperator<_Const>>
  5068	    { return __x._M_inner - __y._M_inner; }
  5069	  };
  5070	
  5071	  template<copy_constructible _Fp, input_range... _Vs>
  5072	    requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && is_object_v<_Fp>
  5073	      && regular_invocable<_Fp&, range_reference_t<_Vs>...>
  5074	      && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
  5075	  template<bool _Const>
  5076	  class zip_transform_view<_Fp, _Vs...>::_Sentinel
  5077	  {
  5078	    __zentinel<_Const> _M_inner;
  5079	
  5080	    constexpr explicit
  5081	    _Sentinel(__zentinel<_Const> __inner)
  5082	      : _M_inner(__inner)
  5083	    { }
  5084	
  5085	    friend class zip_transform_view;
  5086	
  5087	  public:
  5088	    _Sentinel() = default;
  5089	
  5090	    constexpr
  5091	    _Sentinel(_Sentinel<!_Const> __i)
  5092	      requires _Const && convertible_to<__zentinel<false>, __zentinel<_Const>>
  5093	      : _M_inner(std::move(__i._M_inner))
  5094	    { }
  5095	
  5096	    template<bool _OtherConst>
  5097	      requires sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
  5098	    friend constexpr bool
  5099	    operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
  5100	    { return __x._M_inner == __y._M_inner; }
  5101	
  5102	    template<bool _OtherConst>
  5103	      requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
  5104	    friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
  5105	    operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
  5106	    { return __x._M_inner - __y._M_inner; }
  5107	
  5108	    template<bool _OtherConst>
  5109	      requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
  5110	    friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
  5111	    operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y)
  5112	    { return __x._M_inner - __y._M_inner; }
  5113	  };
  5114	
  5115	  namespace views
  5116	  {
  5117	    namespace __detail
  5118	    {
  5119	      template<typename _Fp, typename... _Ts>
  5120		concept __can_zip_transform_view
  5121		  = requires { zip_transform_view(std::declval<_Fp>(), std::declval<_Ts>()...); };
  5122	    }
  5123	
  5124	    struct _ZipTransform
  5125	    {
  5126	      template<typename _Fp, typename... _Ts>
  5127		requires (sizeof...(_Ts) == 0) || __detail::__can_zip_transform_view<_Fp, _Ts...>
  5128		constexpr auto
  5129		operator() [[nodiscard]] (_Fp&& __f, _Ts&&... __ts) const
  5130		{
  5131		  if constexpr (sizeof...(_Ts) == 0)
  5132		    return views::empty<decay_t<invoke_result_t<decay_t<_Fp>&>>>;
  5133		  else
  5134		    return zip_transform_view(std::forward<_Fp>(__f), std::forward<_Ts>(__ts)...);
  5135		}
  5136	    };
  5137	
  5138	    inline constexpr _ZipTransform zip_transform;
  5139	  }
  5140	
  5141	  template<forward_range _Vp, size_t _Nm>
  5142	    requires view<_Vp> && (_Nm > 0)
  5143	  class adjacent_view : public view_interface<adjacent_view<_Vp, _Nm>>
  5144	  {
  5145	    _Vp _M_base = _Vp();
  5146	
  5147	    template<bool> class _Iterator;
  5148	    template<bool> class _Sentinel;
  5149	
  5150	    struct __as_sentinel
  5151	    { };
  5152	
  5153	  public:
  5154	    adjacent_view() requires default_initializable<_Vp> = default;
  5155	
  5156	    constexpr explicit
  5157	    adjacent_view(_Vp __base)
  5158	      : _M_base(std::move(__base))
  5159	    { }
  5160	
  5161	    constexpr auto
  5162	    begin() requires (!__detail::__simple_view<_Vp>)
  5163	    { return _Iterator<false>(ranges::begin(_M_base), ranges::end(_M_base)); }
  5164	
  5165	    constexpr auto
  5166	    begin() const requires range<const _Vp>
  5167	    { return _Iterator<true>(ranges::begin(_M_base), ranges::end(_M_base)); }
  5168	
  5169	    constexpr auto
  5170	    end() requires (!__detail::__simple_view<_Vp>)
  5171	    {
  5172	      if constexpr (common_range<_Vp>)
  5173		return _Iterator<false>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
  5174	      else
  5175		return _Sentinel<false>(ranges::end(_M_base));
  5176	    }
  5177	
  5178	    constexpr auto
  5179	    end() const requires range<const _Vp>
  5180	    {
  5181	      if constexpr (common_range<const _Vp>)
  5182		return _Iterator<true>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
  5183	      else
  5184		return _Sentinel<true>(ranges::end(_M_base));
  5185	    }
  5186	
  5187	    constexpr auto
  5188	    size() requires sized_range<_Vp>
  5189	    {
  5190	      using _ST = decltype(ranges::size(_M_base));
  5191	      using _CT = common_type_t<_ST, size_t>;
  5192	      auto __sz = static_cast<_CT>(ranges::size(_M_base));
  5193	      __sz -= std::min<_CT>(__sz, _Nm - 1);
  5194	      return static_cast<_ST>(__sz);
  5195	    }
  5196	
  5197	    constexpr auto
  5198	    size() const requires sized_range<const _Vp>
  5199	    {
  5200	      using _ST = decltype(ranges::size(_M_base));
  5201	      using _CT = common_type_t<_ST, size_t>;
  5202	      auto __sz = static_cast<_CT>(ranges::size(_M_base));
  5203	      __sz -= std::min<_CT>(__sz, _Nm - 1);
  5204	      return static_cast<_ST>(__sz);
  5205	    }
  5206	  };
  5207	
  5208	  template<typename _Vp, size_t _Nm>
  5209	    inline constexpr bool enable_borrowed_range<adjacent_view<_Vp, _Nm>>
  5210	      = enable_borrowed_range<_Vp>;
  5211	
  5212	  namespace __detail
  5213	  {
  5214	    // Yields tuple<_Tp, ..., _Tp> with _Nm elements.
  5215	    template<typename _Tp, size_t _Nm>
  5216	      using __repeated_tuple = decltype(std::tuple_cat(std::declval<array<_Tp, _Nm>>()));
  5217	
  5218	    // For a functor F that is callable with N arguments, the expression
  5219	    // declval<__unarize<F, N>>(x) is equivalent to declval<F>(x, ..., x).
  5220	    template<typename _Fp, size_t _Nm>
  5221	      struct __unarize
  5222	      {
  5223		template<typename... _Ts>
  5224		  static invoke_result_t<_Fp, _Ts...>
  5225		  __tuple_apply(const tuple<_Ts...>&); // not defined
  5226	
  5227		template<typename _Tp>
  5228		  decltype(__tuple_apply(std::declval<__repeated_tuple<_Tp, _Nm>>()))
  5229		  operator()(_Tp&&); // not defined
  5230	      };
  5231	  }
  5232	
  5233	  template<forward_range _Vp, size_t _Nm>
  5234	    requires view<_Vp> && (_Nm > 0)
  5235	  template<bool _Const>
  5236	  class adjacent_view<_Vp, _Nm>::_Iterator
  5237	  {
  5238	#ifdef __clang__ // LLVM-61763 workaround
  5239	  public:
  5240	#endif
  5241	    using _Base = __detail::__maybe_const_t<_Const, _Vp>;
  5242	    array<iterator_t<_Base>, _Nm> _M_current = array<iterator_t<_Base>, _Nm>();
  5243	
  5244	    constexpr
  5245	    _Iterator(iterator_t<_Base> __first, sentinel_t<_Base> __last)
  5246	    {
  5247	      for (auto& __i : _M_current)
  5248		{
  5249		  __i = __first;
  5250		  ranges::advance(__first, 1, __last);
  5251		}
  5252	    }
  5253	
  5254	    constexpr
  5255	    _Iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last)
  5256	    {
  5257	      if constexpr (!bidirectional_range<_Base>)
  5258		for (auto& __it : _M_current)
  5259		  __it = __last;
  5260	      else
  5261		for (size_t __i = 0; __i < _Nm; ++__i)
  5262		  {
  5263		    _M_current[_Nm - 1 - __i] = __last;
  5264		    ranges::advance(__last, -1, __first);
  5265		  }
  5266	    }
  5267	
  5268	    static auto
  5269	    _S_iter_concept()
  5270	    {
  5271	      if constexpr (random_access_range<_Base>)
  5272		return random_access_iterator_tag{};
  5273	      else if constexpr (bidirectional_range<_Base>)
  5274		return bidirectional_iterator_tag{};
  5275	      else
  5276		return forward_iterator_tag{};
  5277	    }
  5278	
  5279	    friend class adjacent_view;
  5280	
  5281	#ifndef __clang__ // LLVM-61763 workaround
  5282	    template<forward_range _Wp, copy_constructible _Fp, size_t _Mm>
  5283	      requires view<_Wp> && (_Mm > 0) && is_object_v<_Fp>
  5284	        && regular_invocable<__detail::__unarize<_Fp&, _Mm>, range_reference_t<_Wp>>
  5285	        && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Mm>,
  5286								 range_reference_t<_Wp>>>
  5287	      friend class adjacent_transform_view;
  5288	#endif
  5289	
  5290	  public:
  5291	    using iterator_category = input_iterator_tag;
  5292	    using iterator_concept = decltype(_S_iter_concept());
  5293	    using value_type = conditional_t<_Nm == 2,
  5294					     pair<range_value_t<_Base>, range_value_t<_Base>>,
  5295					     __detail::__repeated_tuple<range_value_t<_Base>, _Nm>>;
  5296	    using difference_type = range_difference_t<_Base>;
  5297	
  5298	    _Iterator() = default;
  5299	
  5300	    constexpr
  5301	    _Iterator(_Iterator<!_Const> __i)
  5302	      requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
  5303	    {
  5304	      for (size_t __j = 0; __j < _Nm; ++__j)
  5305		_M_current[__j] = std::move(__i._M_current[__j]);
  5306	    }
  5307	
  5308	    constexpr auto
  5309	    operator*() const
  5310	    {
  5311	      auto __f = [](auto& __i) -> decltype(auto) { return *__i; };
  5312	      return __detail::__tuple_transform(__f, _M_current);
  5313	    }
  5314	
  5315	    constexpr _Iterator&
  5316	    operator++()
  5317	    {
  5318	      for (auto& __i : _M_current)
  5319		++__i;
  5320	      return *this;
  5321	    }
  5322	
  5323	    constexpr _Iterator
  5324	    operator++(int)
  5325	    {
  5326	      auto __tmp = *this;
  5327	      ++*this;
  5328	      return __tmp;
  5329	    }
  5330	
  5331	    constexpr _Iterator&
  5332	    operator--() requires bidirectional_range<_Base>
  5333	    {
  5334	      for (auto& __i : _M_current)
  5335		--__i;
  5336	      return *this;
  5337	    }
  5338	
  5339	    constexpr _Iterator
  5340	    operator--(int) requires bidirectional_range<_Base>
  5341	    {
  5342	      auto __tmp = *this;
  5343	      --*this;
  5344	      return __tmp;
  5345	    }
  5346	
  5347	    constexpr _Iterator&
  5348	    operator+=(difference_type __x)
  5349	      requires random_access_range<_Base>
  5350	    {
  5351	      for (auto& __i : _M_current)
  5352		__i += __x;
  5353	      return *this;
  5354	    }
  5355	
  5356	    constexpr _Iterator&
  5357	    operator-=(difference_type __x)
  5358	      requires random_access_range<_Base>
  5359	    {
  5360	      for (auto& __i : _M_current)
  5361		__i -= __x;
  5362	      return *this;
  5363	    }
  5364	
  5365	    constexpr auto
  5366	    operator[](difference_type __n) const
  5367	      requires random_access_range<_Base>
  5368	    {
  5369	      auto __f = [&](auto& __i) -> decltype(auto) { return __i[__n]; };
  5370	      return __detail::__tuple_transform(__f, _M_current);
  5371	    }
  5372	
  5373	    friend constexpr bool
  5374	    operator==(const _Iterator& __x, const _Iterator& __y)
  5375	    { return __x._M_current.back() == __y._M_current.back(); }
  5376	
  5377	    friend constexpr bool
  5378	    operator<(const _Iterator& __x, const _Iterator& __y)
  5379	      requires random_access_range<_Base>
  5380	    { return __x._M_current.back() < __y._M_current.back(); }
  5381	
  5382	    friend constexpr bool
  5383	    operator>(const _Iterator& __x, const _Iterator& __y)
  5384	      requires random_access_range<_Base>
  5385	    { return __y < __x; }
  5386	
  5387	    friend constexpr bool
  5388	    operator<=(const _Iterator& __x, const _Iterator& __y)
  5389	      requires random_access_range<_Base>
  5390	    { return !(__y < __x); }
  5391	
  5392	    friend constexpr bool
  5393	    operator>=(const _Iterator& __x, const _Iterator& __y)
  5394	      requires random_access_range<_Base>
  5395	    { return !(__x < __y); }
  5396	
  5397	    friend constexpr auto
  5398	    operator<=>(const _Iterator& __x, const _Iterator& __y)
  5399	      requires random_access_range<_Base>
  5400		&& three_way_comparable<iterator_t<_Base>>
  5401	    { return __x._M_current.back() <=> __y._M_current.back(); }
  5402	
  5403	    friend constexpr _Iterator
  5404	    operator+(const _Iterator& __i, difference_type __n)
  5405	      requires random_access_range<_Base>
  5406	    {
  5407	      auto __r = __i;
  5408	      __r += __n;
  5409	      return __r;
  5410	    }
  5411	
  5412	    friend constexpr _Iterator
  5413	    operator+(difference_type __n, const _Iterator& __i)
  5414	      requires random_access_range<_Base>
  5415	    {
  5416	      auto __r = __i;
  5417	      __r += __n;
  5418	      return __r;
  5419	    }
  5420	
  5421	    friend constexpr _Iterator
  5422	    operator-(const _Iterator& __i, difference_type __n)
  5423	      requires random_access_range<_Base>
  5424	    {
  5425	      auto __r = __i;
  5426	      __r -= __n;
  5427	      return __r;
  5428	    }
  5429	
  5430	    friend constexpr difference_type
  5431	    operator-(const _Iterator& __x, const _Iterator& __y)
  5432	      requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
  5433	    { return __x._M_current.back() - __y._M_current.back(); }
  5434	
  5435	    friend constexpr auto
  5436	    iter_move(const _Iterator& __i)
  5437	    { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
  5438	
  5439	    friend constexpr void
  5440	    iter_swap(const _Iterator& __l, const _Iterator& __r)
  5441	      requires indirectly_swappable<iterator_t<_Base>>
  5442	    {
  5443	      for (size_t __i = 0; __i < _Nm; __i++)
  5444		ranges::iter_swap(__l._M_current[__i], __r._M_current[__i]);
  5445	    }
  5446	  };
  5447	
  5448	  template<forward_range _Vp, size_t _Nm>
  5449	    requires view<_Vp> && (_Nm > 0)
  5450	  template<bool _Const>
  5451	  class adjacent_view<_Vp, _Nm>::_Sentinel
  5452	  {
  5453	    using _Base = __detail::__maybe_const_t<_Const, _Vp>;
  5454	
  5455	    sentinel_t<_Base> _M_end = sentinel_t<_Base>();
  5456	
  5457	    constexpr explicit
  5458	    _Sentinel(sentinel_t<_Base> __end)
  5459	      : _M_end(__end)
  5460	    { }
  5461	
  5462	    friend class adjacent_view;
  5463	
  5464	  public:
  5465	    _Sentinel() = default;
  5466	
  5467	    constexpr
  5468	    _Sentinel(_Sentinel<!_Const> __i)
  5469	      requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
  5470	      : _M_end(std::move(__i._M_end))
  5471	    { }
  5472	
  5473	    template<bool _OtherConst>
  5474	      requires sentinel_for<sentinel_t<_Base>,
  5475				    iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
  5476	    friend constexpr bool
  5477	    operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
  5478	    { return __x._M_current.back() == __y._M_end; }
  5479	
  5480	    template<bool _OtherConst>
  5481	      requires sized_sentinel_for<sentinel_t<_Base>,
  5482					  iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
  5483	    friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
  5484	    operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
  5485	    { return __x._M_current.back() - __y._M_end; }
  5486	
  5487	    template<bool _OtherConst>
  5488	      requires sized_sentinel_for<sentinel_t<_Base>,
  5489					  iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
  5490	    friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
  5491	    operator-(const _Sentinel& __y, const _Iterator<_OtherConst>& __x)
  5492	    { return __y._M_end - __x._M_current.back(); }
  5493	  };
  5494	
  5495	  namespace views
  5496	  {
  5497	    namespace __detail
  5498	    {
  5499	      template<size_t _Nm, typename _Range>
  5500		concept __can_adjacent_view
  5501		  = requires { adjacent_view<all_t<_Range>, _Nm>(std::declval<_Range>()); };
  5502	    }
  5503	
  5504	    template<size_t _Nm>
  5505	      struct _Adjacent : __adaptor::_RangeAdaptorClosure
  5506	      {
  5507		template<viewable_range _Range>
  5508		  requires (_Nm == 0) || __detail::__can_adjacent_view<_Nm, _Range>
  5509		  constexpr auto
  5510		  operator() [[nodiscard]] (_Range&& __r) const
  5511		  {
  5512		    if constexpr (_Nm == 0)
  5513		      return views::empty<tuple<>>;
  5514		    else
  5515		      return adjacent_view<all_t<_Range>, _Nm>(std::forward<_Range>(__r));
  5516		  }
  5517	      };
  5518	
  5519	    template<size_t _Nm>
  5520	      inline constexpr _Adjacent<_Nm> adjacent;
  5521	
  5522	    inline constexpr auto pairwise = adjacent<2>;
  5523	  }
  5524	
  5525	  template<forward_range _Vp, copy_constructible _Fp, size_t _Nm>
  5526	   requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
  5527	     && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
  5528	     && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
  5529							       range_reference_t<_Vp>>>
  5530	  class adjacent_transform_view : public view_interface<adjacent_transform_view<_Vp, _Fp, _Nm>>
  5531	  {
  5532	    [[no_unique_address]] __detail::__box<_Fp> _M_fun;
  5533	    adjacent_view<_Vp, _Nm> _M_inner;
  5534	
  5535	    using _InnerView = adjacent_view<_Vp, _Nm>;
  5536	
  5537	    template<bool _Const>
  5538	      using _InnerIter = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
  5539	
  5540	    template<bool _Const>
  5541	      using _InnerSent = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
  5542	
  5543	    template<bool> class _Iterator;
  5544	    template<bool> class _Sentinel;
  5545	
  5546	  public:
  5547	    adjacent_transform_view() = default;
  5548	
  5549	    constexpr explicit
  5550	    adjacent_transform_view(_Vp __base, _Fp __fun)
  5551	      : _M_fun(std::move(__fun)), _M_inner(std::move(__base))
  5552	    { }
  5553	
  5554	    constexpr auto
  5555	    begin()
  5556	    { return _Iterator<false>(*this, _M_inner.begin()); }
  5557	
  5558	    constexpr auto
  5559	    begin() const
  5560	      requires range<const _InnerView>
  5561		&& regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
  5562				     range_reference_t<const _Vp>>
  5563	    { return _Iterator<true>(*this, _M_inner.begin()); }
  5564	
  5565	    constexpr auto
  5566	    end()
  5567	    {
  5568	      if constexpr (common_range<_InnerView>)
  5569	        return _Iterator<false>(*this, _M_inner.end());
  5570	      else
  5571	        return _Sentinel<false>(_M_inner.end());
  5572	    }
  5573	
  5574	    constexpr auto
  5575	    end() const
  5576	      requires range<const _InnerView>
  5577		&& regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
  5578				     range_reference_t<const _Vp>>
  5579	    {
  5580	      if constexpr (common_range<const _InnerView>)
  5581	        return _Iterator<true>(*this, _M_inner.end());
  5582	      else
  5583	        return _Sentinel<true>(_M_inner.end());
  5584	    }
  5585	
  5586	    constexpr auto
  5587	    size() requires sized_range<_InnerView>
  5588	    { return _M_inner.size(); }
  5589	
  5590	    constexpr auto
  5591	    size() const requires sized_range<const _InnerView>
  5592	    { return _M_inner.size(); }
  5593	  };
  5594	
  5595	  template<forward_range _Vp, copy_constructible _Fp, size_t _Nm>
  5596	   requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
  5597	     && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
  5598	     && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
  5599							       range_reference_t<_Vp>>>
  5600	  template<bool _Const>
  5601	  class adjacent_transform_view<_Vp, _Fp, _Nm>::_Iterator
  5602	  {
  5603	    using _Parent = __detail::__maybe_const_t<_Const, adjacent_transform_view>;
  5604	    using _Base = __detail::__maybe_const_t<_Const, _Vp>;
  5605	
  5606	    _Parent* _M_parent = nullptr;
  5607	    _InnerIter<_Const> _M_inner;
  5608	
  5609	    constexpr
  5610	    _Iterator(_Parent& __parent, _InnerIter<_Const> __inner)
  5611	      : _M_parent(std::__addressof(__parent)), _M_inner(std::move(__inner))
  5612	    { }
  5613	
  5614	    static auto
  5615	    _S_iter_cat()
  5616	    {
  5617	      using __detail::__maybe_const_t;
  5618	      using __detail::__unarize;
  5619	      using _Res = invoke_result_t<__unarize<__maybe_const_t<_Const, _Fp>&, _Nm>,
  5620					   range_reference_t<_Base>>;
  5621	      using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
  5622	      if constexpr (!is_lvalue_reference_v<_Res>)
  5623		return input_iterator_tag{};
  5624	      else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
  5625		return random_access_iterator_tag{};
  5626	      else if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
  5627		return bidirectional_iterator_tag{};
  5628	      else if constexpr (derived_from<_Cat, forward_iterator_tag>)
  5629		return forward_iterator_tag{};
  5630	      else
  5631		return input_iterator_tag{};
  5632	    }
  5633	
  5634	    friend class adjacent_transform_view;
  5635	
  5636	  public:
  5637	    using iterator_category = decltype(_S_iter_cat());
  5638	    using iterator_concept = typename _InnerIter<_Const>::iterator_concept;
  5639	    using value_type
  5640	      = remove_cvref_t<invoke_result_t
  5641			       <__detail::__unarize<__detail::__maybe_const_t<_Const, _Fp>&, _Nm>,
  5642				range_reference_t<_Base>>>;
  5643	    using difference_type = range_difference_t<_Base>;
  5644	
  5645	    _Iterator() = default;
  5646	
  5647	    constexpr
  5648	    _Iterator(_Iterator<!_Const> __i)
  5649	      requires _Const && convertible_to<_InnerIter<false>, _InnerIter<_Const>>
  5650	      : _M_parent(__i._M_parent), _M_inner(std::move(__i._M_inner))
  5651	    { }
  5652	
  5653	    constexpr decltype(auto)
  5654	    operator*() const
  5655	    {
  5656	      return std::apply([&](const auto&... __iters) -> decltype(auto) {
  5657	        return std::__invoke(*_M_parent->_M_fun, *__iters...);
  5658	      }, _M_inner._M_current);
  5659	    }
  5660	
  5661	    constexpr _Iterator&
  5662	    operator++()
  5663	    {
  5664	      ++_M_inner;
  5665	      return *this;
  5666	    }
  5667	
  5668	    constexpr _Iterator
  5669	    operator++(int)
  5670	    {
  5671	      auto __tmp = *this;
  5672	      ++*this;
  5673	      return __tmp;
  5674	    }
  5675	
  5676	    constexpr _Iterator&
  5677	    operator--() requires bidirectional_range<_Base>
  5678	    {
  5679	      --_M_inner;
  5680	      return *this;
  5681	    }
  5682	
  5683	    constexpr _Iterator
  5684	    operator--(int) requires bidirectional_range<_Base>
  5685	    {
  5686	      auto __tmp = *this;
  5687	      --*this;
  5688	      return __tmp;
  5689	    }
  5690	
  5691	    constexpr _Iterator&
  5692	    operator+=(difference_type __x) requires random_access_range<_Base>
  5693	    {
  5694	      _M_inner += __x;
  5695	      return *this;
  5696	    }
  5697	
  5698	    constexpr _Iterator&
  5699	    operator-=(difference_type __x) requires random_access_range<_Base>
  5700	    {
  5701	      _M_inner -= __x;
  5702	      return *this;
  5703	    }
  5704	
  5705	    constexpr decltype(auto)
  5706	    operator[](difference_type __n) const requires random_access_range<_Base>
  5707	    {
  5708	      return std::apply([&](const auto&... __iters) -> decltype(auto) {
  5709	        return std::__invoke(*_M_parent->_M_fun, __iters[__n]...);
  5710	      }, _M_inner._M_current);
  5711	    }
  5712	
  5713	    friend constexpr bool
  5714	    operator==(const _Iterator& __x, const _Iterator& __y)
  5715	    { return __x._M_inner == __y._M_inner; }
  5716	
  5717	    friend constexpr bool
  5718	    operator<(const _Iterator& __x, const _Iterator& __y)
  5719	      requires random_access_range<_Base>
  5720	    { return __x._M_inner < __y._M_inner; }
  5721	
  5722	    friend constexpr bool
  5723	    operator>(const _Iterator& __x, const _Iterator& __y)
  5724	      requires random_access_range<_Base>
  5725	    { return __x._M_inner > __y._M_inner; }
  5726	
  5727	    friend constexpr bool
  5728	    operator<=(const _Iterator& __x, const _Iterator& __y)
  5729	      requires random_access_range<_Base>
  5730	    { return __x._M_inner <= __y._M_inner; }
  5731	
  5732	    friend constexpr bool
  5733	    operator>=(const _Iterator& __x, const _Iterator& __y)
  5734	      requires random_access_range<_Base>
  5735	    { return __x._M_inner >= __y._M_inner; }
  5736	
  5737	    friend constexpr auto
  5738	    operator<=>(const _Iterator& __x, const _Iterator& __y)
  5739	      requires random_access_range<_Base> &&
  5740	      three_way_comparable<_InnerIter<_Const>>
  5741	    { return __x._M_inner <=> __y._M_inner; }
  5742	
  5743	    friend constexpr _Iterator
  5744	    operator+(const _Iterator& __i, difference_type __n)
  5745	      requires random_access_range<_Base>
  5746	    { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
  5747	
  5748	    friend constexpr _Iterator
  5749	    operator+(difference_type __n, const _Iterator& __i)
  5750	      requires random_access_range<_Base>
  5751	    { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
  5752	
  5753	    friend constexpr _Iterator
  5754	    operator-(const _Iterator& __i, difference_type __n)
  5755	      requires random_access_range<_Base>
  5756	    { return _Iterator(*__i._M_parent, __i._M_inner - __n); }
  5757	
  5758	    friend constexpr difference_type
  5759	    operator-(const _Iterator& __x, const _Iterator& __y)
  5760	      requires sized_sentinel_for<_InnerIter<_Const>, _InnerIter<_Const>>
  5761	    { return __x._M_inner - __y._M_inner; }
  5762	  };
  5763	
  5764	  template<forward_range _Vp, copy_constructible _Fp, size_t _Nm>
  5765	   requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
  5766	     && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
  5767	     && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
  5768							       range_reference_t<_Vp>>>
  5769	  template<bool _Const>
  5770	  class adjacent_transform_view<_Vp, _Fp, _Nm>::_Sentinel
  5771	  {
  5772	    _InnerSent<_Const> _M_inner;
  5773	
  5774	    constexpr explicit
  5775	    _Sentinel(_InnerSent<_Const> __inner)
  5776	      : _M_inner(__inner)
  5777	    { }
  5778	
  5779	    friend class adjacent_transform_view;
  5780	
  5781	  public:
  5782	    _Sentinel() = default;
  5783	
  5784	    constexpr
  5785	    _Sentinel(_Sentinel<!_Const> __i)
  5786	      requires _Const && convertible_to<_InnerSent<false>, _InnerSent<_Const>>
  5787	      : _M_inner(std::move(__i._M_inner))
  5788	    { }
  5789	
  5790	    template<bool _OtherConst>
  5791	      requires sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
  5792	    friend constexpr bool
  5793	    operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
  5794	    { return __x._M_inner == __y._M_inner; }
  5795	
  5796	    template<bool _OtherConst>
  5797	      requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
  5798	    friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
  5799	    operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
  5800	    { return __x._M_inner - __y._M_inner; }
  5801	
  5802	    template<bool _OtherConst>
  5803	      requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
  5804	    friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
  5805	    operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y)
  5806	    { return __x._M_inner - __y._M_inner; }
  5807	  };
  5808	
  5809	  namespace views
  5810	  {
  5811	    namespace __detail
  5812	    {
  5813	      template<size_t _Nm, typename _Range, typename _Fp>
  5814		concept __can_adjacent_transform_view
  5815		  = requires { adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
  5816			         (std::declval<_Range>(), std::declval<_Fp>()); };
  5817	    }
  5818	
  5819	    template<size_t _Nm>
  5820	      struct _AdjacentTransform : __adaptor::_RangeAdaptor<_AdjacentTransform<_Nm>>
  5821	      {
  5822		template<viewable_range _Range, typename _Fp>
  5823		  requires (_Nm == 0) || __detail::__can_adjacent_transform_view<_Nm, _Range, _Fp>
  5824		  constexpr auto
  5825		  operator() [[nodiscard]] (_Range&& __r, _Fp&& __f) const
  5826		  {
  5827		    if constexpr (_Nm == 0)
  5828		      return zip_transform(std::forward<_Fp>(__f));
  5829		    else
  5830		      return adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
  5831			(std::forward<_Range>(__r), std::forward<_Fp>(__f));
  5832		  }
  5833	
  5834		using __adaptor::_RangeAdaptor<_AdjacentTransform>::operator();
  5835		static constexpr int _S_arity = 2;
  5836		static constexpr bool _S_has_simple_extra_args = true;
  5837	      };
  5838	
  5839	    template<size_t _Nm>
  5840	      inline constexpr _AdjacentTransform<_Nm> adjacent_transform;
  5841	
  5842	    inline constexpr auto pairwise_transform = adjacent_transform<2>;
  5843	  }
  5844	
  5845	#define __cpp_lib_ranges_chunk 202202L
  5846	
  5847	  namespace __detail
  5848	  {
  5849	    template<typename _Tp>
  5850	    constexpr _Tp __div_ceil(_Tp __num, _Tp __denom)
  5851	    {
  5852	      _Tp __r = __num / __denom;
  5853	      if (__num % __denom)
  5854		++__r;
  5855	      return __r;
  5856	    }
  5857	  }
  5858	
  5859	  template<view _Vp>
  5860	    requires input_range<_Vp>
  5861	  class chunk_view : public view_interface<chunk_view<_Vp>>
  5862	  {
  5863	    _Vp _M_base;
  5864	    range_difference_t<_Vp> _M_n;
  5865	    range_difference_t<_Vp> _M_remainder = 0;
  5866	    __detail::__non_propagating_cache<iterator_t<_Vp>> _M_current;
  5867	
  5868	    class _OuterIter;
  5869	    class _InnerIter;
  5870	
  5871	  public:
  5872	    constexpr explicit
  5873	    chunk_view(_Vp __base, range_difference_t<_Vp> __n)
  5874	      : _M_base(std::move(__base)), _M_n(__n)
  5875	    { __glibcxx_assert(__n >= 0); }
  5876	
  5877	    constexpr _Vp
  5878	    base() const & requires copy_constructible<_Vp>
  5879	    { return _M_base; }
  5880	
  5881	    constexpr _Vp
  5882	    base() &&
  5883	    { return std::move(_M_base); }
  5884	
  5885	    constexpr _OuterIter
  5886	    begin()
  5887	    {
  5888	      _M_current = ranges::begin(_M_base);
  5889	      _M_remainder = _M_n;
  5890	      return _OuterIter(*this);
  5891	    }
  5892	
  5893	    constexpr default_sentinel_t
  5894	    end() const noexcept
  5895	    { return default_sentinel; }
  5896	
  5897	    constexpr auto
  5898	    size() requires sized_range<_Vp>
  5899	    {
  5900	      return __detail::__to_unsigned_like(__detail::__div_ceil
  5901						  (ranges::distance(_M_base), _M_n));
  5902	    }
  5903	
  5904	    constexpr auto
  5905	    size() const requires sized_range<const _Vp>
  5906	    {
  5907	      return __detail::__to_unsigned_like(__detail::__div_ceil
  5908						  (ranges::distance(_M_base), _M_n));
  5909	    }
  5910	  };
  5911	
  5912	  template<typename _Range>
  5913	    chunk_view(_Range&&, range_difference_t<_Range>) -> chunk_view<views::all_t<_Range>>;
  5914	
  5915	  template<view _Vp>
  5916	    requires input_range<_Vp>
  5917	  class chunk_view<_Vp>::_OuterIter
  5918	  {
  5919	    chunk_view* _M_parent;
  5920	
  5921	    constexpr explicit
  5922	    _OuterIter(chunk_view& __parent) noexcept
  5923	      : _M_parent(std::__addressof(__parent))
  5924	    { }
  5925	
  5926	    friend chunk_view;
  5927	
  5928	  public:
  5929	    using iterator_concept = input_iterator_tag;
  5930	    using difference_type = range_difference_t<_Vp>;
  5931	
  5932	    struct value_type;
  5933	
  5934	    _OuterIter(_OuterIter&&) = default;
  5935	    _OuterIter& operator=(_OuterIter&&) = default;
  5936	
  5937	    constexpr value_type
  5938	    operator*() const
  5939	    {
  5940	      __glibcxx_assert(*this != default_sentinel);
  5941	      return value_type(*_M_parent);
  5942	    }
  5943	
  5944	    constexpr _OuterIter&
  5945	    operator++()
  5946	    {
  5947	      __glibcxx_assert(*this != default_sentinel);
  5948	      ranges::advance(*_M_parent->_M_current, _M_parent->_M_remainder,
  5949			      ranges::end(_M_parent->_M_base));
  5950	      _M_parent->_M_remainder = _M_parent->_M_n;
  5951	      return *this;
  5952	    }
  5953	
  5954	    constexpr void
  5955	    operator++(int)
  5956	    { ++*this; }
  5957	
  5958	    friend constexpr bool
  5959	    operator==(const _OuterIter& __x, default_sentinel_t)
  5960	    {
  5961	      return *__x._M_parent->_M_current == ranges::end(__x._M_parent->_M_base)
  5962		&& __x._M_parent->_M_remainder != 0;
  5963	    }
  5964	
  5965	    friend constexpr difference_type
  5966	    operator-(default_sentinel_t, const _OuterIter& __x)
  5967	    requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
  5968	    {
  5969	      const auto __dist = ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current;
  5970	
  5971	      if (__dist < __x._M_parent->_M_remainder)
  5972		return __dist == 0 ? 0 : 1;
  5973	
  5974	      return 1 + __detail::__div_ceil(__dist - __x._M_parent->_M_remainder,
  5975					      __x._M_parent->_M_n);
  5976	    }
  5977	
  5978	    friend constexpr difference_type
  5979	    operator-(const _OuterIter& __x, default_sentinel_t __y)
  5980	    requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
  5981	    { return -(__y - __x); }
  5982	  };
  5983	
  5984	  template<view _Vp>
  5985	    requires input_range<_Vp>
  5986	  struct chunk_view<_Vp>::_OuterIter::value_type : view_interface<value_type>
  5987	  {
  5988	  private:
  5989	    chunk_view* _M_parent;
  5990	
  5991	    constexpr explicit
  5992	    value_type(chunk_view& __parent) noexcept
  5993	    : _M_parent(std::__addressof(__parent))
  5994	    { }
  5995	
  5996	    friend _OuterIter;
  5997	
  5998	  public:
  5999	    constexpr _InnerIter
  6000	    begin() const noexcept
  6001	    { return _InnerIter(*_M_parent); }
  6002	
  6003	    constexpr default_sentinel_t
  6004	    end() const noexcept
  6005	    { return default_sentinel; }
  6006	
  6007	    constexpr auto
  6008	    size() const
  6009	    requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
  6010	    {
  6011	      return __detail::__to_unsigned_like
  6012		(ranges::min(_M_parent->_M_remainder,
  6013			     ranges::end(_M_parent->_M_base) - *_M_parent->_M_current));
  6014	    }
  6015	  };
  6016	
  6017	  template<view _Vp>
  6018	    requires input_range<_Vp>
  6019	  class chunk_view<_Vp>::_InnerIter
  6020	  {
  6021	    chunk_view* _M_parent;
  6022	
  6023	    constexpr explicit
  6024	    _InnerIter(chunk_view& __parent) noexcept
  6025	    : _M_parent(std::__addressof(__parent))
  6026	    { }
  6027	
  6028	    friend _OuterIter::value_type;
  6029	
  6030	  public:
  6031	    using iterator_concept = input_iterator_tag;
  6032	    using difference_type = range_difference_t<_Vp>;
  6033	    using value_type = range_value_t<_Vp>;
  6034	
  6035	    _InnerIter(_InnerIter&&) = default;
  6036	    _InnerIter& operator=(_InnerIter&&) = default;
  6037	
  6038	    constexpr const iterator_t<_Vp>&
  6039	    base() const &
  6040	    { return *_M_parent->_M_current; }
  6041	
  6042	    constexpr range_reference_t<_Vp>
  6043	    operator*() const
  6044	    {
  6045	      __glibcxx_assert(*this != default_sentinel);
  6046	      return **_M_parent->_M_current;
  6047	    }
  6048	
  6049	    constexpr _InnerIter&
  6050	    operator++()
  6051	    {
  6052	      __glibcxx_assert(*this != default_sentinel);
  6053	      ++*_M_parent->_M_current;
  6054	      if (*_M_parent->_M_current == ranges::end(_M_parent->_M_base))
  6055		_M_parent->_M_remainder = 0;
  6056	      else
  6057		--_M_parent->_M_remainder;
  6058	      return *this;
  6059	    }
  6060	
  6061	    constexpr void
  6062	    operator++(int)
  6063	    { ++*this; }
  6064	
  6065	    friend constexpr bool
  6066	    operator==(const _InnerIter& __x, default_sentinel_t) noexcept
  6067	    { return __x._M_parent->_M_remainder == 0; }
  6068	
  6069	    friend constexpr difference_type
  6070	    operator-(default_sentinel_t, const _InnerIter& __x)
  6071	      requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
  6072	    {
  6073	      return ranges::min(__x._M_parent->_M_remainder,
  6074				 ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current);
  6075	    }
  6076	
  6077	    friend constexpr difference_type
  6078	    operator-(const _InnerIter& __x, default_sentinel_t __y)
  6079	      requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
  6080	    { return -(__y - __x); }
  6081	  };
  6082	
  6083	  template<view _Vp>
  6084	    requires forward_range<_Vp>
  6085	  class chunk_view<_Vp> : public view_interface<chunk_view<_Vp>>
  6086	  {
  6087	    _Vp _M_base;
  6088	    range_difference_t<_Vp> _M_n;
  6089	    template<bool> class _Iterator;
  6090	
  6091	  public:
  6092	    constexpr explicit
  6093	    chunk_view(_Vp __base, range_difference_t<_Vp> __n)
  6094	    : _M_base(std::move(__base)), _M_n(__n)
  6095	    { __glibcxx_assert(__n > 0); }
  6096	
  6097	    constexpr _Vp
  6098	    base() const & requires copy_constructible<_Vp>
  6099	    { return _M_base; }
  6100	
  6101	    constexpr _Vp
  6102	    base() &&
  6103	    { return std::move(_M_base); }
  6104	
  6105	    constexpr auto
  6106	    begin() requires (!__detail::__simple_view<_Vp>)
  6107	    { return _Iterator<false>(this, ranges::begin(_M_base)); }
  6108	
  6109	    constexpr auto
  6110	    begin() const requires forward_range<const _Vp>
  6111	    { return _Iterator<true>(this, ranges::begin(_M_base)); }
  6112	
  6113	    constexpr auto
  6114	    end() requires (!__detail::__simple_view<_Vp>)
  6115	    {
  6116	      if constexpr (common_range<_Vp> && sized_range<_Vp>)
  6117		{
  6118		  auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
  6119		  return _Iterator<false>(this, ranges::end(_M_base), __missing);
  6120		}
  6121	      else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
  6122		return _Iterator<false>(this, ranges::end(_M_base));
  6123	      else
  6124		return default_sentinel;
  6125	    }
  6126	
  6127	    constexpr auto
  6128	    end() const requires forward_range<const _Vp>
  6129	    {
  6130	      if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
  6131		{
  6132		  auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
  6133		  return _Iterator<true>(this, ranges::end(_M_base), __missing);
  6134		}
  6135	      else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
  6136		return _Iterator<true>(this, ranges::end(_M_base));
  6137	      else
  6138		return default_sentinel;
  6139	    }
  6140	
  6141	    constexpr auto
  6142	    size() requires sized_range<_Vp>
  6143	    {
  6144	      return __detail::__to_unsigned_like(__detail::__div_ceil
  6145						  (ranges::distance(_M_base), _M_n));
  6146	    }
  6147	
  6148	    constexpr auto
  6149	    size() const requires sized_range<const _Vp>
  6150	    {
  6151	      return __detail::__to_unsigned_like(__detail::__div_ceil
  6152						  (ranges::distance(_M_base), _M_n));
  6153	    }
  6154	  };
  6155	
  6156	  template<typename _Vp>
  6157	    inline constexpr bool enable_borrowed_range<chunk_view<_Vp>>
  6158	      = forward_range<_Vp> && enable_borrowed_range<_Vp>;
  6159	
  6160	  template<view _Vp>
  6161	    requires forward_range<_Vp>
  6162	  template<bool _Const>
  6163	  class chunk_view<_Vp>::_Iterator
  6164	  {
  6165	    using _Parent = __detail::__maybe_const_t<_Const, chunk_view>;
  6166	    using _Base = __detail::__maybe_const_t<_Const, _Vp>;
  6167	
  6168	    iterator_t<_Base> _M_current = iterator_t<_Base>();
  6169	    sentinel_t<_Base> _M_end = sentinel_t<_Base>();
  6170	    range_difference_t<_Base> _M_n = 0;
  6171	    range_difference_t<_Base> _M_missing = 0;
  6172	
  6173	    constexpr
  6174	    _Iterator(_Parent* __parent, iterator_t<_Base> __current,
  6175		      range_difference_t<_Base> __missing = 0)
  6176	    : _M_current(__current), _M_end(ranges::end(__parent->_M_base)),
  6177	      _M_n(__parent->_M_n), _M_missing(__missing)
  6178	    { }
  6179	
  6180	    static auto
  6181	    _S_iter_cat()
  6182	    {
  6183	      if constexpr (random_access_range<_Base>)
  6184		return random_access_iterator_tag{};
  6185	      else if constexpr (bidirectional_range<_Base>)
  6186		return bidirectional_iterator_tag{};
  6187	      else
  6188		return forward_iterator_tag{};
  6189	    }
  6190	
  6191	    friend chunk_view;
  6192	
  6193	  public:
  6194	    using iterator_category = input_iterator_tag;
  6195	    using iterator_concept = decltype(_S_iter_cat());
  6196	    using value_type = decltype(views::take(subrange(_M_current, _M_end), _M_n));
  6197	    using difference_type = range_difference_t<_Base>;
  6198	
  6199	    _Iterator() = default;
  6200	
  6201	    constexpr _Iterator(_Iterator<!_Const> __i)
  6202	      requires _Const
  6203		&& convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
  6204		&& convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
  6205	    : _M_current(std::move(__i._M_current)), _M_end(std::move(__i._M_end)),
  6206	      _M_n(__i._M_n), _M_missing(__i._M_missing)
  6207	    { }
  6208	
  6209	    constexpr iterator_t<_Base>
  6210	    base() const
  6211	    { return _M_current; }
  6212	
  6213	    constexpr value_type
  6214	    operator*() const
  6215	    {
  6216	      __glibcxx_assert(_M_current != _M_end);
  6217	      return views::take(subrange(_M_current, _M_end), _M_n);
  6218	    }
  6219	
  6220	    constexpr _Iterator&
  6221	    operator++()
  6222	    {
  6223	      __glibcxx_assert(_M_current != _M_end);
  6224	      _M_missing = ranges::advance(_M_current, _M_n, _M_end);
  6225	      return *this;
  6226	    }
  6227	
  6228	    constexpr _Iterator
  6229	    operator++(int)
  6230	    {
  6231	      auto __tmp = *this;
  6232	      ++*this;
  6233	      return __tmp;
  6234	    }
  6235	
  6236	    constexpr _Iterator&
  6237	    operator--() requires bidirectional_range<_Base>
  6238	    {
  6239	      ranges::advance(_M_current, _M_missing - _M_n);
  6240	      _M_missing = 0;
  6241	      return *this;
  6242	    }
  6243	
  6244	    constexpr _Iterator
  6245	    operator--(int) requires bidirectional_range<_Base>
  6246	    {
  6247	      auto __tmp = *this;
  6248	      --*this;
  6249	      return __tmp;
  6250	    }
  6251	
  6252	    constexpr _Iterator&
  6253	    operator+=(difference_type __x)
  6254	      requires random_access_range<_Base>
  6255	    {
  6256	      if (__x > 0)
  6257		{
  6258		  __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_n * (__x - 1));
  6259		  _M_missing = ranges::advance(_M_current, _M_n * __x, _M_end);
  6260		}
  6261	      else if (__x < 0)
  6262		{
  6263		  ranges::advance(_M_current, _M_n * __x + _M_missing);
  6264		  _M_missing = 0;
  6265		}
  6266	      return *this;
  6267	    }
  6268	
  6269	    constexpr _Iterator&
  6270	    operator-=(difference_type __x)
  6271	      requires random_access_range<_Base>
  6272	    { return *this += -__x; }
  6273	
  6274	    constexpr value_type
  6275	    operator[](difference_type __n) const
  6276	      requires random_access_range<_Base>
  6277	    { return *(*this + __n); }
  6278	
  6279	    friend constexpr bool
  6280	    operator==(const _Iterator& __x, const _Iterator& __y)
  6281	    { return __x._M_current == __y._M_current; }
  6282	
  6283	    friend constexpr bool
  6284	    operator==(const _Iterator& __x, default_sentinel_t)
  6285	    { return __x._M_current == __x._M_end; }
  6286	
  6287	    friend constexpr bool
  6288	    operator<(const _Iterator& __x, const _Iterator& __y)
  6289	      requires random_access_range<_Base>
  6290	    { return __x._M_current > __y._M_current; }
  6291	
  6292	    friend constexpr bool
  6293	    operator>(const _Iterator& __x, const _Iterator& __y)
  6294	      requires random_access_range<_Base>
  6295	    { return __y < __x; }
  6296	
  6297	    friend constexpr bool
  6298	    operator<=(const _Iterator& __x, const _Iterator& __y)
  6299	      requires random_access_range<_Base>
  6300	    { return !(__y < __x); }
  6301	
  6302	    friend constexpr bool
  6303	    operator>=(const _Iterator& __x, const _Iterator& __y)
  6304	      requires random_access_range<_Base>
  6305	    { return !(__x < __y); }
  6306	
  6307	    friend constexpr auto
  6308	    operator<=>(const _Iterator& __x, const _Iterator& __y)
  6309	      requires random_access_range<_Base>
  6310		&& three_way_comparable<iterator_t<_Base>>
  6311	    { return __x._M_current <=> __y._M_current; }
  6312	
  6313	    friend constexpr _Iterator
  6314	    operator+(const _Iterator& __i, difference_type __n)
  6315	      requires random_access_range<_Base>
  6316	    {
  6317	      auto __r  = __i;
  6318	      __r += __n;
  6319	      return __r;
  6320	    }
  6321	
  6322	    friend constexpr _Iterator
  6323	    operator+(difference_type __n, const _Iterator& __i)
  6324	      requires random_access_range<_Base>
  6325	    {
  6326	      auto __r  = __i;
  6327	      __r += __n;
  6328	      return __r;
  6329	    }
  6330	
  6331	    friend constexpr _Iterator
  6332	    operator-(const _Iterator& __i, difference_type __n)
  6333	      requires random_access_range<_Base>
  6334	    {
  6335	      auto __r  = __i;
  6336	      __r -= __n;
  6337	      return __r;
  6338	    }
  6339	
  6340	    friend constexpr difference_type
  6341	    operator-(const _Iterator& __x, const _Iterator& __y)
  6342	      requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
  6343	    {
  6344	      return (__x._M_current - __y._M_current
  6345		      + __x._M_missing - __y._M_missing) / __x._M_n;
  6346	    }
  6347	
  6348	    friend constexpr difference_type
  6349	    operator-(default_sentinel_t __y, const _Iterator& __x)
  6350	      requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
  6351	    { return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_n); }
  6352	
  6353	    friend constexpr difference_type
  6354	    operator-(const _Iterator& __x, default_sentinel_t __y)
  6355	      requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
  6356	    { return -(__y - __x); }
  6357	  };
  6358	
  6359	  namespace views
  6360	  {
  6361	    namespace __detail
  6362	    {
  6363	      template<typename _Range, typename _Dp>
  6364		concept __can_chunk_view
  6365		  = requires { chunk_view(std::declval<_Range>(), std::declval<_Dp>()); };
  6366	    }
  6367	
  6368	    struct _Chunk : __adaptor::_RangeAdaptor<_Chunk>
  6369	    {
  6370	      template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
  6371		requires __detail::__can_chunk_view<_Range, _Dp>
  6372		constexpr auto
  6373		operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
  6374		{ return chunk_view(std::forward<_Range>(__r), __n); }
  6375	
  6376	      using __adaptor::_RangeAdaptor<_Chunk>::operator();
  6377	      static constexpr int _S_arity = 2;
  6378	      static constexpr bool _S_has_simple_extra_args = true;
  6379	    };
  6380	
  6381	    inline constexpr _Chunk chunk;
  6382	  }
  6383	
  6384	#define __cpp_lib_ranges_slide 202202L
  6385	
  6386	  namespace __detail
  6387	  {
  6388	    template<typename _Vp>
  6389	      concept __slide_caches_nothing = random_access_range<_Vp> && sized_range<_Vp>;
  6390	
  6391	    template<typename _Vp>
  6392	      concept __slide_caches_last
  6393	      = !__slide_caches_nothing<_Vp> && bidirectional_range<_Vp> && common_range<_Vp>;
  6394	
  6395	    template<typename _Vp>
  6396	      concept __slide_caches_first
  6397	      = !__slide_caches_nothing<_Vp> && !__slide_caches_last<_Vp>;
  6398	  }
  6399	
  6400	  template<forward_range _Vp>
  6401	    requires view<_Vp>
  6402	  class slide_view : public view_interface<slide_view<_Vp>>
  6403	  {
  6404	    _Vp _M_base;
  6405	    range_difference_t<_Vp> _M_n;
  6406	    [[no_unique_address]]
  6407	      __detail::__maybe_present_t<__detail::__slide_caches_first<_Vp>,
  6408					  __detail::_CachedPosition<_Vp>> _M_cached_begin;
  6409	    [[no_unique_address]]
  6410	      __detail::__maybe_present_t<__detail::__slide_caches_last<_Vp>,
  6411					  __detail::_CachedPosition<_Vp>> _M_cached_end;
  6412	
  6413	    template<bool> class _Iterator;
  6414	    class _Sentinel;
  6415	
  6416	  public:
  6417	    constexpr explicit
  6418	    slide_view(_Vp __base, range_difference_t<_Vp> __n)
  6419	    : _M_base(std::move(__base)), _M_n(__n)
  6420	    { __glibcxx_assert(__n > 0); }
  6421	
  6422	    constexpr auto
  6423	    begin() requires (!(__detail::__simple_view<_Vp>
  6424				&& __detail::__slide_caches_nothing<const _Vp>))
  6425	    {
  6426	      if constexpr (__detail::__slide_caches_first<_Vp>)
  6427		{
  6428		  iterator_t<_Vp> __it;
  6429		  if (_M_cached_begin._M_has_value())
  6430		    __it = _M_cached_begin._M_get(_M_base);
  6431		  else
  6432		    {
  6433		      __it = ranges::next(ranges::begin(_M_base), _M_n - 1, ranges::end(_M_base));
  6434		      _M_cached_begin._M_set(_M_base, __it);
  6435		    }
  6436		  return _Iterator<false>(ranges::begin(_M_base), std::move(__it), _M_n);
  6437		}
  6438	      else
  6439		return _Iterator<false>(ranges::begin(_M_base), _M_n);
  6440	    }
  6441	
  6442	    constexpr auto
  6443	    begin() const requires __detail::__slide_caches_nothing<const _Vp>
  6444	    { return _Iterator<true>(ranges::begin(_M_base), _M_n); }
  6445	
  6446	    constexpr auto
  6447	    end() requires (!(__detail::__simple_view<_Vp>
  6448			      && __detail::__slide_caches_nothing<const _Vp>))
  6449	    {
  6450	      if constexpr (__detail::__slide_caches_nothing<_Vp>)
  6451		return _Iterator<false>(ranges::begin(_M_base) + range_difference_t<_Vp>(size()),
  6452					_M_n);
  6453	      else if constexpr (__detail::__slide_caches_last<_Vp>)
  6454		{
  6455		  iterator_t<_Vp> __it;
  6456		  if (_M_cached_end._M_has_value())
  6457		    __it = _M_cached_end._M_get(_M_base);
  6458		  else
  6459		    {
  6460		      __it = ranges::prev(ranges::end(_M_base), _M_n - 1, ranges::begin(_M_base));
  6461		      _M_cached_end._M_set(_M_base, __it);
  6462		    }
  6463		  return _Iterator<false>(std::move(__it), _M_n);
  6464		}
  6465	      else if constexpr (common_range<_Vp>)
  6466		return _Iterator<false>(ranges::end(_M_base), ranges::end(_M_base), _M_n);
  6467	      else
  6468		return _Sentinel(ranges::end(_M_base));
  6469	    }
  6470	
  6471	    constexpr auto
  6472	    end() const requires __detail::__slide_caches_nothing<const _Vp>
  6473	    { return begin() + range_difference_t<const _Vp>(size()); }
  6474	
  6475	    constexpr auto
  6476	    size() requires sized_range<_Vp>
  6477	    {
  6478	      auto __sz = ranges::distance(_M_base) - _M_n + 1;
  6479	      if (__sz < 0)
  6480		__sz = 0;
  6481	      return __detail::__to_unsigned_like(__sz);
  6482	    }
  6483	
  6484	    constexpr auto
  6485	    size() const requires sized_range<const _Vp>
  6486	    {
  6487	      auto __sz = ranges::distance(_M_base) - _M_n + 1;
  6488	      if (__sz < 0)
  6489		__sz = 0;
  6490	      return __detail::__to_unsigned_like(__sz);
  6491	    }
  6492	  };
  6493	
  6494	  template<typename _Range>
  6495	    slide_view(_Range&&, range_difference_t<_Range>) -> slide_view<views::all_t<_Range>>;
  6496	
  6497	  template<typename _Vp>
  6498	    inline constexpr bool enable_borrowed_range<slide_view<_Vp>>
  6499	      = enable_borrowed_range<_Vp>;
  6500	
  6501	  template<forward_range _Vp>
  6502	    requires view<_Vp>
  6503	  template<bool _Const>
  6504	  class slide_view<_Vp>::_Iterator
  6505	  {
  6506	    using _Base = __detail::__maybe_const_t<_Const, _Vp>;
  6507	    static constexpr bool _S_last_elt_present
  6508	      = __detail::__slide_caches_first<_Base>;
  6509	
  6510	    iterator_t<_Base> _M_current = iterator_t<_Base>();
  6511	    [[no_unique_address]]
  6512	      __detail::__maybe_present_t<_S_last_elt_present, iterator_t<_Base>>
  6513		_M_last_elt = decltype(_M_last_elt)();
  6514	    range_difference_t<_Base> _M_n = 0;
  6515	
  6516	    constexpr
  6517	    _Iterator(iterator_t<_Base> __current, range_difference_t<_Base> __n)
  6518	      requires (!_S_last_elt_present)
  6519	    : _M_current(__current), _M_n(__n)
  6520	    { }
  6521	
  6522	    constexpr
  6523	    _Iterator(iterator_t<_Base> __current, iterator_t<_Base> __last_elt,
  6524		      range_difference_t<_Base> __n)
  6525	      requires _S_last_elt_present
  6526	    : _M_current(__current), _M_last_elt(__last_elt), _M_n(__n)
  6527	    { }
  6528	
  6529	    static auto
  6530	    _S_iter_concept()
  6531	    {
  6532	      if constexpr (random_access_range<_Base>)
  6533		return random_access_iterator_tag{};
  6534	      else if constexpr (bidirectional_range<_Base>)
  6535		return bidirectional_iterator_tag{};
  6536	      else
  6537		return forward_iterator_tag{};
  6538	    }
  6539	
  6540	    friend slide_view;
  6541	    friend slide_view::_Sentinel;
  6542	
  6543	  public:
  6544	    using iterator_category = input_iterator_tag;
  6545	    using iterator_concept = decltype(_S_iter_concept());
  6546	    using value_type = decltype(views::counted(_M_current, _M_n));
  6547	    using difference_type = range_difference_t<_Base>;
  6548	
  6549	    _Iterator() = default;
  6550	
  6551	    constexpr
  6552	    _Iterator(_Iterator<!_Const> __i)
  6553	      requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
  6554	    : _M_current(std::move(__i._M_current)), _M_n(__i._M_n)
  6555	    { }
  6556	
  6557	    constexpr auto
  6558	    operator*() const
  6559	    { return views::counted(_M_current, _M_n); }
  6560	
  6561	    constexpr _Iterator&
  6562	    operator++()
  6563	    {
  6564	      ++_M_current;
  6565	      if constexpr (_S_last_elt_present)
  6566		++_M_last_elt;
  6567	      return *this;
  6568	    }
  6569	
  6570	    constexpr _Iterator
  6571	    operator++(int)
  6572	    {
  6573	      auto __tmp = *this;
  6574	      ++*this;
  6575	      return __tmp;
  6576	    }
  6577	
  6578	    constexpr _Iterator&
  6579	    operator--() requires bidirectional_range<_Base>
  6580	    {
  6581	      --_M_current;
  6582	      if constexpr (_S_last_elt_present)
  6583		--_M_last_elt;
  6584	      return *this;
  6585	    }
  6586	
  6587	    constexpr _Iterator
  6588	    operator--(int) requires bidirectional_range<_Base>
  6589	    {
  6590	      auto __tmp = *this;
  6591	      --*this;
  6592	      return __tmp;
  6593	    }
  6594	
  6595	    constexpr _Iterator&
  6596	    operator+=(difference_type __x)
  6597	      requires random_access_range<_Base>
  6598	    {
  6599	      _M_current += __x;
  6600	      if constexpr (_S_last_elt_present)
  6601		_M_last_elt += __x;
  6602	      return *this;
  6603	    }
  6604	
  6605	    constexpr _Iterator&
  6606	    operator-=(difference_type __x)
  6607	      requires random_access_range<_Base>
  6608	    {
  6609	      _M_current -= __x;
  6610	      if constexpr (_S_last_elt_present)
  6611		_M_last_elt -= __x;
  6612	      return *this;
  6613	    }
  6614	
  6615	    constexpr auto
  6616	    operator[](difference_type __n) const
  6617	      requires random_access_range<_Base>
  6618	    { return views::counted(_M_current + __n, _M_n); }
  6619	
  6620	    friend constexpr bool
  6621	    operator==(const _Iterator& __x, const _Iterator& __y)
  6622	    {
  6623	      if constexpr (_S_last_elt_present)
  6624		return __x._M_last_elt == __y._M_last_elt;
  6625	      else
  6626		return __x._M_current == __y._M_current;
  6627	    }
  6628	
  6629	    friend constexpr bool
  6630	    operator<(const _Iterator& __x, const _Iterator& __y)
  6631	      requires random_access_range<_Base>
  6632	    { return __x._M_current < __y._M_current; }
  6633	
  6634	    friend constexpr bool
  6635	    operator>(const _Iterator& __x, const _Iterator& __y)
  6636	      requires random_access_range<_Base>
  6637	    { return __y < __x; }
  6638	
  6639	    friend constexpr bool
  6640	    operator<=(const _Iterator& __x, const _Iterator& __y)
  6641	      requires random_access_range<_Base>
  6642	    { return !(__y < __x); }
  6643	
  6644	    friend constexpr bool
  6645	    operator>=(const _Iterator& __x, const _Iterator& __y)
  6646	      requires random_access_range<_Base>
  6647	    { return !(__x < __y); }
  6648	
  6649	    friend constexpr auto
  6650	    operator<=>(const _Iterator& __x, const _Iterator& __y)
  6651	      requires random_access_range<_Base>
  6652		&& three_way_comparable<iterator_t<_Base>>
  6653	     { return __x._M_current <=> __y._M_current; }
  6654	
  6655	    friend constexpr _Iterator
  6656	    operator+(const _Iterator& __i, difference_type __n)
  6657	      requires random_access_range<_Base>
  6658	    {
  6659	      auto __r = __i;
  6660	      __r += __n;
  6661	      return __r;
  6662	    }
  6663	
  6664	    friend constexpr _Iterator
  6665	    operator+(difference_type __n, const _Iterator& __i)
  6666	      requires random_access_range<_Base>
  6667	    {
  6668	      auto __r = __i;
  6669	      __r += __n;
  6670	      return __r;
  6671	    }
  6672	
  6673	    friend constexpr _Iterator
  6674	    operator-(const _Iterator& __i, difference_type __n)
  6675	      requires random_access_range<_Base>
  6676	    {
  6677	      auto __r = __i;
  6678	      __r -= __n;
  6679	      return __r;
  6680	    }
  6681	
  6682	    friend constexpr difference_type
  6683	    operator-(const _Iterator& __x, const _Iterator& __y)
  6684	      requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
  6685	    {
  6686	      if constexpr (_S_last_elt_present)
  6687		return __x._M_last_elt - __y._M_last_elt;
  6688	      else
  6689		return __x._M_current - __y._M_current;
  6690	    }
  6691	  };
  6692	
  6693	  template<forward_range _Vp>
  6694	    requires view<_Vp>
  6695	  class slide_view<_Vp>::_Sentinel
  6696	  {
  6697	    sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
  6698	
  6699	    constexpr explicit
  6700	    _Sentinel(sentinel_t<_Vp> __end)
  6701	    : _M_end(__end)
  6702	    { }
  6703	
  6704	    friend slide_view;
  6705	
  6706	  public:
  6707	    _Sentinel() = default;
  6708	
  6709	    friend constexpr bool
  6710	    operator==(const _Iterator<false>& __x, const _Sentinel& __y)
  6711	    { return __x._M_last_elt == __y._M_end; }
  6712	
  6713	    friend constexpr range_difference_t<_Vp>
  6714	    operator-(const _Iterator<false>& __x, const _Sentinel& __y)
  6715	      requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
  6716	    { return __x._M_last_elt - __y._M_end; }
  6717	
  6718	    friend constexpr range_difference_t<_Vp>
  6719	    operator-(const _Sentinel& __y, const _Iterator<false>& __x)
  6720	      requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
  6721	    { return __y._M_end -__x._M_last_elt; }
  6722	  };
  6723	
  6724	  namespace views
  6725	  {
  6726	    namespace __detail
  6727	    {
  6728	      template<typename _Range, typename _Dp>
  6729		concept __can_slide_view
  6730		  = requires { slide_view(std::declval<_Range>(), std::declval<_Dp>()); };
  6731	    }
  6732	
  6733	    struct _Slide : __adaptor::_RangeAdaptor<_Slide>
  6734	    {
  6735	      template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
  6736		requires __detail::__can_slide_view<_Range, _Dp>
  6737		constexpr auto
  6738		operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
  6739		{ return slide_view(std::forward<_Range>(__r), __n); }
  6740	
  6741	      using __adaptor::_RangeAdaptor<_Slide>::operator();
  6742	      static constexpr int _S_arity = 2;
  6743	      static constexpr bool _S_has_simple_extra_args = true;
  6744	    };
  6745	
  6746	    inline constexpr _Slide slide;
  6747	  }
  6748	
  6749	#define __cpp_lib_ranges_chunk_by 202202L
  6750	
  6751	  template<forward_range _Vp,
  6752		   indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
  6753	    requires view<_Vp> && is_object_v<_Pred>
  6754	  class chunk_by_view : public view_interface<chunk_by_view<_Vp, _Pred>>
  6755	  {
  6756	    _Vp _M_base = _Vp();
  6757	    __detail::__box<_Pred> _M_pred;
  6758	    __detail::_CachedPosition<_Vp> _M_cached_begin;
  6759	
  6760	    constexpr iterator_t<_Vp>
  6761	    _M_find_next(iterator_t<_Vp> __current)
  6762	    {
  6763	      __glibcxx_assert(_M_pred.has_value());
  6764	      auto __pred = [this]<typename _Tp, typename _Up>(_Tp&& __x, _Up&& __y) {
  6765		return !bool((*_M_pred)(std::forward<_Tp>(__x), std::forward<_Up>(__y)));
  6766	      };
  6767	      auto __it = ranges::adjacent_find(__current, ranges::end(_M_base), __pred);
  6768	      return ranges::next(__it, 1, ranges::end(_M_base));
  6769	    }
  6770	
  6771	    constexpr iterator_t<_Vp>
  6772	    _M_find_prev(iterator_t<_Vp> __current) requires bidirectional_range<_Vp>
  6773	    {
  6774	      __glibcxx_assert(_M_pred.has_value());
  6775	      auto __pred = [this]<typename _Tp, typename _Up>(_Tp&& __x, _Up&& __y) {
  6776		return !bool((*_M_pred)(std::forward<_Up>(__y), std::forward<_Tp>(__x)));
  6777	      };
  6778	      auto __rbegin = std::make_reverse_iterator(__current);
  6779	      auto __rend = std::make_reverse_iterator(ranges::begin(_M_base));
  6780	      __glibcxx_assert(__rbegin != __rend);
  6781	      auto __it = ranges::adjacent_find(__rbegin, __rend, __pred).base();
  6782	      return ranges::prev(__it, 1, ranges::begin(_M_base));
  6783	    }
  6784	
  6785	    class _Iterator;
  6786	
  6787	  public:
  6788	    chunk_by_view() requires (default_initializable<_Vp>
  6789				      && default_initializable<_Pred>)
  6790	      = default;
  6791	
  6792	    constexpr explicit
  6793	    chunk_by_view(_Vp __base, _Pred __pred)
  6794	    : _M_base(std::move(__base)), _M_pred(std::move(__pred))
  6795	    { }
  6796	
  6797	    constexpr _Vp
  6798	    base() const & requires copy_constructible<_Vp>
  6799	    { return _M_base; }
  6800	
  6801	    constexpr _Vp
  6802	    base() &&
  6803	    { return std::move(_M_base); }
  6804	
  6805	    constexpr const _Pred&
  6806	    pred() const
  6807	    { return *_M_pred; }
  6808	
  6809	    constexpr _Iterator
  6810	    begin()
  6811	    {
  6812	      __glibcxx_assert(_M_pred.has_value());
  6813	      iterator_t<_Vp> __it;
  6814	      if (_M_cached_begin._M_has_value())
  6815		__it = _M_cached_begin._M_get(_M_base);
  6816	      else
  6817		{
  6818		  __it = _M_find_next(ranges::begin(_M_base));
  6819		  _M_cached_begin._M_set(_M_base, __it);
  6820		}
  6821	      return _Iterator(*this, ranges::begin(_M_base), __it);
  6822	    }
  6823	
  6824	    constexpr auto
  6825	    end()
  6826	    {
  6827	      if constexpr (common_range<_Vp>)
  6828		return _Iterator(*this, ranges::end(_M_base), ranges::end(_M_base));
  6829	      else
  6830		return default_sentinel;
  6831	    }
  6832	  };
  6833	
  6834	  template<typename _Range, typename _Pred>
  6835	    chunk_by_view(_Range&&, _Pred) -> chunk_by_view<views::all_t<_Range>, _Pred>;
  6836	
  6837	  template<forward_range _Vp,
  6838		   indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
  6839	    requires view<_Vp> && is_object_v<_Pred>
  6840	  class chunk_by_view<_Vp, _Pred>::_Iterator
  6841	  {
  6842	    chunk_by_view* _M_parent = nullptr;
  6843	    iterator_t<_Vp> _M_current = iterator_t<_Vp>();
  6844	    iterator_t<_Vp> _M_next = iterator_t<_Vp>();
  6845	
  6846	    constexpr
  6847	    _Iterator(chunk_by_view& __parent, iterator_t<_Vp> __current, iterator_t<_Vp> __next)
  6848	    : _M_parent(std::__addressof(__parent)), _M_current(__current), _M_next(__next)
  6849	    { }
  6850	
  6851	    static auto
  6852	    _S_iter_concept()
  6853	    {
  6854	      if constexpr (bidirectional_range<_Vp>)
  6855		return bidirectional_iterator_tag{};
  6856	      else
  6857		return forward_iterator_tag{};
  6858	    }
  6859	
  6860	    friend chunk_by_view;
  6861	
  6862	  public:
  6863	    using value_type = subrange<iterator_t<_Vp>>;
  6864	    using difference_type = range_difference_t<_Vp>;
  6865	    using iterator_category = input_iterator_tag;
  6866	    using iterator_concept = decltype(_S_iter_concept());
  6867	
  6868	    _Iterator() = default;
  6869	
  6870	    constexpr value_type
  6871	    operator*() const
  6872	    {
  6873	      __glibcxx_assert(_M_current != _M_next);
  6874	      return ranges::subrange(_M_current, _M_next);
  6875	    }
  6876	
  6877	    constexpr _Iterator&
  6878	    operator++()
  6879	    {
  6880	      __glibcxx_assert(_M_current != _M_next);
  6881	      _M_current = _M_next;
  6882	      _M_next = _M_parent->_M_find_next(_M_current);
  6883	      return *this;
  6884	    }
  6885	
  6886	    constexpr _Iterator
  6887	    operator++(int)
  6888	    {
  6889	      auto __tmp = *this;
  6890	      ++*this;
  6891	      return __tmp;
  6892	    }
  6893	
  6894	    constexpr _Iterator&
  6895	    operator--() requires bidirectional_range<_Vp>
  6896	    {
  6897	      _M_next = _M_current;
  6898	      _M_current = _M_parent->_M_find_prev(_M_next);
  6899	      return *this;
  6900	    }
  6901	
  6902	    constexpr _Iterator
  6903	    operator--(int) requires bidirectional_range<_Vp>
  6904	    {
  6905	      auto __tmp = *this;
  6906	      --*this;
  6907	      return __tmp;
  6908	    }
  6909	
  6910	    friend constexpr bool
  6911	    operator==(const _Iterator& __x, const _Iterator& __y)
  6912	    { return __x._M_current == __y._M_current; }
  6913	
  6914	    friend constexpr bool
  6915	    operator==(const _Iterator& __x, default_sentinel_t)
  6916	    { return __x._M_current == __x._M_next; }
  6917	  };
  6918	
  6919	  namespace views
  6920	  {
  6921	    namespace __detail
  6922	    {
  6923	      template<typename _Range, typename _Pred>
  6924		concept __can_chunk_by_view
  6925		  = requires { chunk_by_view(std::declval<_Range>(), std::declval<_Pred>()); };
  6926	    }
  6927	
  6928	    struct _ChunkBy : __adaptor::_RangeAdaptor<_ChunkBy>
  6929	    {
  6930	      template<viewable_range _Range, typename _Pred>
  6931		requires __detail::__can_chunk_by_view<_Range, _Pred>
  6932		constexpr auto
  6933		operator() [[nodiscard]] (_Range&& __r, _Pred&& __pred) const
  6934		{ return chunk_by_view(std::forward<_Range>(__r), std::forward<_Pred>(__pred)); }
  6935	
  6936	      using __adaptor::_RangeAdaptor<_ChunkBy>::operator();
  6937	      static constexpr int _S_arity = 2;
  6938	      static constexpr bool _S_has_simple_extra_args = true;
  6939	    };
  6940	
  6941	    inline constexpr _ChunkBy chunk_by;
  6942	  }
  6943	
  6944	#define __cpp_lib_ranges_join_with 202202L
  6945	
  6946	  namespace __detail
  6947	  {
  6948	    template<typename _Range, typename _Pattern>
  6949	      concept __compatible_joinable_ranges
  6950		= common_with<range_value_t<_Range>, range_value_t<_Pattern>>
  6951		  && common_reference_with<range_reference_t<_Range>,
  6952					   range_reference_t<_Pattern>>
  6953		  && common_reference_with<range_rvalue_reference_t<_Range>,
  6954					   range_rvalue_reference_t<_Pattern>>;
  6955	
  6956	    template<typename _Range>
  6957	      concept __bidirectional_common = bidirectional_range<_Range> && common_range<_Range>;
  6958	  }
  6959	
  6960	  template<input_range _Vp, forward_range _Pattern>
  6961	    requires view<_Vp> && view<_Pattern>
  6962	      && input_range<range_reference_t<_Vp>>
  6963	      && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
  6964	  class join_with_view : public view_interface<join_with_view<_Vp, _Pattern>>
  6965	  {
  6966	    using _InnerRange = range_reference_t<_Vp>;
  6967	
  6968	    _Vp _M_base = _Vp();
  6969	    __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
  6970	    _Pattern _M_pattern = _Pattern();
  6971	
  6972	    template<bool _Const> using _Base = __detail::__maybe_const_t<_Const, _Vp>;
  6973	    template<bool _Const> using _InnerBase = range_reference_t<_Base<_Const>>;
  6974	    template<bool _Const> using _PatternBase = __detail::__maybe_const_t<_Const, _Pattern>;
  6975	
  6976	    template<bool _Const> using _OuterIter = iterator_t<_Base<_Const>>;
  6977	    template<bool _Const> using _InnerIter = iterator_t<_InnerBase<_Const>>;
  6978	    template<bool _Const> using _PatternIter = iterator_t<_PatternBase<_Const>>;
  6979	
  6980	    template<bool _Const>
  6981	      static constexpr bool _S_ref_is_glvalue = is_reference_v<_InnerBase<_Const>>;
  6982	
  6983	    template<bool _Const>
  6984	    struct __iter_cat
  6985	    { };
  6986	
  6987	    template<bool _Const>
  6988	      requires _S_ref_is_glvalue<_Const>
  6989		&& forward_range<_Base<_Const>>
  6990		&& forward_range<_InnerBase<_Const>>
  6991	    struct __iter_cat<_Const>
  6992	    {
  6993	      private:
  6994		static auto
  6995		_S_iter_cat()
  6996		{
  6997		  using _OuterIter = join_with_view::_OuterIter<_Const>;
  6998		  using _InnerIter = join_with_view::_InnerIter<_Const>;
  6999		  using _PatternIter = join_with_view::_PatternIter<_Const>;
  7000		  using _OuterCat = typename iterator_traits<_OuterIter>::iterator_category;
  7001		  using _InnerCat = typename iterator_traits<_InnerIter>::iterator_category;
  7002		  using _PatternCat = typename iterator_traits<_PatternIter>::iterator_category;
  7003		  if constexpr (!is_lvalue_reference_v<common_reference_t<iter_reference_t<_InnerIter>,
  7004									  iter_reference_t<_PatternIter>>>)
  7005		    return input_iterator_tag{};
  7006		  else if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
  7007				     && derived_from<_InnerCat, bidirectional_iterator_tag>
  7008				     && derived_from<_PatternCat, bidirectional_iterator_tag>
  7009				     && common_range<_InnerBase<_Const>>
  7010				     && common_range<_PatternBase<_Const>>)
  7011		    return bidirectional_iterator_tag{};
  7012		  else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
  7013				     && derived_from<_InnerCat, forward_iterator_tag>
  7014				     && derived_from<_PatternCat, forward_iterator_tag>)
  7015		    return forward_iterator_tag{};
  7016		  else
  7017		    return input_iterator_tag{};
  7018		}
  7019	      public:
  7020		using iterator_category = decltype(_S_iter_cat());
  7021	    };
  7022	
  7023	    template<bool> struct _Iterator;
  7024	    template<bool> struct _Sentinel;
  7025	
  7026	  public:
  7027	    join_with_view() requires (default_initializable<_Vp>
  7028				       && default_initializable<_Pattern>)
  7029	      = default;
  7030	
  7031	    constexpr
  7032	    join_with_view(_Vp __base, _Pattern __pattern)
  7033	    : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
  7034	    { }
  7035	
  7036	    template<input_range _Range>
  7037	      requires constructible_from<_Vp, views::all_t<_Range>>
  7038		&& constructible_from<_Pattern, single_view<range_value_t<_InnerRange>>>
  7039	    constexpr
  7040	    join_with_view(_Range&& __r, range_value_t<_InnerRange> __e)
  7041	    : _M_base(views::all(std::forward<_Range>(__r))),
  7042	      _M_pattern(views::single(std::move(__e)))
  7043	    { }
  7044	
  7045	    constexpr _Vp
  7046	    base() const& requires copy_constructible<_Vp>
  7047	    { return _M_base; }
  7048	
  7049	    constexpr _Vp
  7050	    base() &&
  7051	    { return std::move(_M_base); }
  7052	
  7053	    constexpr auto
  7054	    begin()
  7055	    {
  7056	      constexpr bool __use_const = is_reference_v<_InnerRange>
  7057		&& __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
  7058	      return _Iterator<__use_const>{*this, ranges::begin(_M_base)};
  7059	    }
  7060	
  7061	    constexpr auto
  7062	    begin() const
  7063	      requires input_range<const _Vp>
  7064		&& forward_range<const _Pattern>
  7065		&& is_reference_v<range_reference_t<const _Vp>>
  7066	    { return _Iterator<true>{*this, ranges::begin(_M_base)}; }
  7067	
  7068	    constexpr auto
  7069	    end()
  7070	    {
  7071	      constexpr bool __use_const
  7072		= __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
  7073	      if constexpr (is_reference_v<_InnerRange>
  7074			    && forward_range<_Vp> && common_range<_Vp>
  7075			    && forward_range<_InnerRange> && common_range<_InnerRange>)
  7076	        return _Iterator<__use_const>{*this, ranges::end(_M_base)};
  7077	      else
  7078	        return _Sentinel<__use_const>{*this};
  7079	    }
  7080	
  7081	    constexpr auto
  7082	    end() const
  7083	      requires input_range<const _Vp>
  7084		&& forward_range<const _Pattern>
  7085		&& is_reference_v<range_reference_t<const _Vp>>
  7086	    {
  7087	      using _InnerConstRange = range_reference_t<const _Vp>;
  7088	      if constexpr (forward_range<const _Vp>
  7089			    && forward_range<_InnerConstRange>
  7090			    && common_range<const _Vp>
  7091			    && common_range<_InnerConstRange>)
  7092	        return _Iterator<true>{*this, ranges::end(_M_base)};
  7093	      else
  7094	        return _Sentinel<true>{*this};
  7095	    }
  7096	  };
  7097	
  7098	  template<typename _Range, typename _Pattern>
  7099	    join_with_view(_Range&&, _Pattern&&)
  7100	      -> join_with_view<views::all_t<_Range>, views::all_t<_Pattern>>;
  7101	
  7102	  template<input_range _Range>
  7103	    join_with_view(_Range&&, range_value_t<range_reference_t<_Range>>)
  7104	      -> join_with_view<views::all_t<_Range>,
  7105				single_view<range_value_t<range_reference_t<_Range>>>>;
  7106	
  7107	  template<input_range _Vp, forward_range _Pattern>
  7108	    requires view<_Vp> && view<_Pattern>
  7109	      && input_range<range_reference_t<_Vp>>
  7110	      && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
  7111	  template<bool _Const>
  7112	  class join_with_view<_Vp, _Pattern>::_Iterator : public __iter_cat<_Const>
  7113	  {
  7114	    using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
  7115	    using _Base = join_with_view::_Base<_Const>;
  7116	    using _InnerBase = join_with_view::_InnerBase<_Const>;
  7117	    using _PatternBase = join_with_view::_PatternBase<_Const>;
  7118	
  7119	    using _OuterIter = join_with_view::_OuterIter<_Const>;
  7120	    using _InnerIter = join_with_view::_InnerIter<_Const>;
  7121	    using _PatternIter = join_with_view::_PatternIter<_Const>;
  7122	
  7123	    static constexpr bool _S_ref_is_glvalue = join_with_view::_S_ref_is_glvalue<_Const>;
  7124	
  7125	    _Parent* _M_parent = nullptr;
  7126	    _OuterIter _M_outer_it = _OuterIter();
  7127	    variant<_PatternIter, _InnerIter> _M_inner_it;
  7128	
  7129	    constexpr
  7130	    _Iterator(_Parent& __parent, iterator_t<_Base> __outer)
  7131	    : _M_parent(std::__addressof(__parent)), _M_outer_it(std::move(__outer))
  7132	    {
  7133	      if (_M_outer_it != ranges::end(_M_parent->_M_base))
  7134		{
  7135		  auto&& __inner = _M_update_inner(_M_outer_it);
  7136		  _M_inner_it.template emplace<1>(ranges::begin(__inner));
  7137		  _M_satisfy();
  7138		}
  7139	    }
  7140	
  7141	    constexpr auto&&
  7142	    _M_update_inner(const _OuterIter& __x)
  7143	    {
  7144	      if constexpr (_S_ref_is_glvalue)
  7145		return *__x;
  7146	      else
  7147		return _M_parent->_M_inner._M_emplace_deref(__x);
  7148	    }
  7149	
  7150	    constexpr auto&&
  7151	    _M_get_inner(const _OuterIter& __x)
  7152	    {
  7153	      if constexpr (_S_ref_is_glvalue)
  7154		return *__x;
  7155	      else
  7156		return *_M_parent->_M_inner;
  7157	    }
  7158	
  7159	    constexpr void
  7160	    _M_satisfy()
  7161	    {
  7162	      while (true)
  7163		{
  7164		  if (_M_inner_it.index() == 0)
  7165		    {
  7166		      if (std::get<0>(_M_inner_it) != ranges::end(_M_parent->_M_pattern))
  7167			break;
  7168	
  7169		      auto&& __inner = _M_update_inner(_M_outer_it);
  7170		      _M_inner_it.template emplace<1>(ranges::begin(__inner));
  7171		    }
  7172		  else
  7173		    {
  7174		      auto&& __inner = _M_get_inner(_M_outer_it);
  7175		      if (std::get<1>(_M_inner_it) != ranges::end(__inner))
  7176			break;
  7177	
  7178		      if (++_M_outer_it == ranges::end(_M_parent->_M_base))
  7179			{
  7180			  if constexpr (_S_ref_is_glvalue)
  7181			    _M_inner_it.template emplace<0>();
  7182			  break;
  7183			}
  7184	
  7185		      _M_inner_it.template emplace<0>(ranges::begin(_M_parent->_M_pattern));
  7186		    }
  7187		}
  7188	    }
  7189	
  7190	    static auto
  7191	    _S_iter_concept()
  7192	    {
  7193	      if constexpr (_S_ref_is_glvalue
  7194			    && bidirectional_range<_Base>
  7195			    && __detail::__bidirectional_common<_InnerBase>
  7196			    && __detail::__bidirectional_common<_PatternBase>)
  7197		return bidirectional_iterator_tag{};
  7198	      else if constexpr (_S_ref_is_glvalue
  7199				 && forward_range<_Base>
  7200				 && forward_range<_InnerBase>)
  7201		return forward_iterator_tag{};
  7202	      else
  7203		return input_iterator_tag{};
  7204	    }
  7205	
  7206	    friend join_with_view;
  7207	
  7208	  public:
  7209	    using iterator_concept = decltype(_S_iter_concept());
  7210	    // iterator_category defined in join_with_view::__iter_cat
  7211	    using value_type = common_type_t<iter_value_t<_InnerIter>,
  7212					     iter_value_t<_PatternIter>>;
  7213	    using difference_type = common_type_t<iter_difference_t<_OuterIter>,
  7214						  iter_difference_t<_InnerIter>,
  7215						  iter_difference_t<_PatternIter>>;
  7216	
  7217	    _Iterator() requires default_initializable<_OuterIter> = default;
  7218	
  7219	    constexpr
  7220	    _Iterator(_Iterator<!_Const> __i)
  7221	      requires _Const
  7222		&& convertible_to<iterator_t<_Vp>, _OuterIter>
  7223		&& convertible_to<iterator_t<_InnerRange>, _InnerIter>
  7224		&& convertible_to<iterator_t<_Pattern>, _PatternIter>
  7225	    : _M_parent(__i._M_parent),
  7226	      _M_outer_it(std::move(__i._M_outer_it))
  7227	    {
  7228	      if (__i._M_inner_it.index() == 0)
  7229		_M_inner_it.template emplace<0>(std::get<0>(std::move(__i._M_inner_it)));
  7230	      else
  7231		_M_inner_it.template emplace<1>(std::get<1>(std::move(__i._M_inner_it)));
  7232	    }
  7233	
  7234	    constexpr common_reference_t<iter_reference_t<_InnerIter>,
  7235				         iter_reference_t<_PatternIter>>
  7236	    operator*() const
  7237	    {
  7238	      if (_M_inner_it.index() == 0)
  7239		return *std::get<0>(_M_inner_it);
  7240	      else
  7241		return *std::get<1>(_M_inner_it);
  7242	    }
  7243	
  7244	    constexpr _Iterator&
  7245	    operator++()
  7246	    {
  7247	      if (_M_inner_it.index() == 0)
  7248		++std::get<0>(_M_inner_it);
  7249	      else
  7250		++std::get<1>(_M_inner_it);
  7251	      _M_satisfy();
  7252	      return *this;
  7253	    }
  7254	
  7255	    constexpr void
  7256	    operator++(int)
  7257	    { ++*this; }
  7258	
  7259	    constexpr _Iterator
  7260	    operator++(int)
  7261	      requires _S_ref_is_glvalue
  7262		&& forward_iterator<_OuterIter> && forward_iterator<_InnerIter>
  7263	    {
  7264	      _Iterator __tmp = *this;
  7265	      ++*this;
  7266	      return __tmp;
  7267	    }
  7268	
  7269	    constexpr _Iterator&
  7270	    operator--()
  7271	      requires _S_ref_is_glvalue
  7272		&& bidirectional_range<_Base>
  7273		&& __detail::__bidirectional_common<_InnerBase>
  7274		&& __detail::__bidirectional_common<_PatternBase>
  7275	    {
  7276	      if (_M_outer_it == ranges::end(_M_parent->_M_base))
  7277		{
  7278		  auto&& __inner = *--_M_outer_it;
  7279		  _M_inner_it.template emplace<1>(ranges::end(__inner));
  7280		}
  7281	
  7282	      while (true)
  7283		{
  7284		  if (_M_inner_it.index() == 0)
  7285		    {
  7286		      auto& __it = std::get<0>(_M_inner_it);
  7287		      if (__it == ranges::begin(_M_parent->_M_pattern))
  7288			{
  7289			  auto&& __inner = *--_M_outer_it;
  7290			  _M_inner_it.template emplace<1>(ranges::end(__inner));
  7291			}
  7292		      else
  7293			break;
  7294		    }
  7295		  else
  7296		    {
  7297		      auto& __it = std::get<1>(_M_inner_it);
  7298		      auto&& __inner = *_M_outer_it;
  7299		      if (__it == ranges::begin(__inner))
  7300			_M_inner_it.template emplace<0>(ranges::end(_M_parent->_M_pattern));
  7301		      else
  7302			break;
  7303		    }
  7304		}
  7305	
  7306	      if (_M_inner_it.index() == 0)
  7307		--std::get<0>(_M_inner_it);
  7308	      else
  7309		--std::get<1>(_M_inner_it);
  7310	      return *this;
  7311	    }
  7312	
  7313	    constexpr _Iterator
  7314	    operator--(int)
  7315	      requires _S_ref_is_glvalue && bidirectional_range<_Base>
  7316		&& __detail::__bidirectional_common<_InnerBase>
  7317		&& __detail::__bidirectional_common<_PatternBase>
  7318	    {
  7319	      _Iterator __tmp = *this;
  7320	      --*this;
  7321	      return __tmp;
  7322	    }
  7323	
  7324	    friend constexpr bool
  7325	    operator==(const _Iterator& __x, const _Iterator& __y)
  7326	      requires _S_ref_is_glvalue
  7327		&& equality_comparable<_OuterIter> && equality_comparable<_InnerIter>
  7328	    { return __x._M_outer_it == __y._M_outer_it && __x._M_inner_it ==__y._M_inner_it; }
  7329	
  7330	    friend constexpr common_reference_t<iter_rvalue_reference_t<_InnerIter>,
  7331						iter_rvalue_reference_t<_PatternIter>>
  7332	    iter_move(const _Iterator& __x)
  7333	    {
  7334	      if (__x._M_inner_it.index() == 0)
  7335		return ranges::iter_move(std::get<0>(__x._M_inner_it));
  7336	      else
  7337		return ranges::iter_move(std::get<1>(__x._M_inner_it));
  7338	    }
  7339	
  7340	    friend constexpr void
  7341	    iter_swap(const _Iterator& __x, const _Iterator& __y)
  7342	      requires indirectly_swappable<_InnerIter, _PatternIter>
  7343	    {
  7344	      if (__x._M_inner_it.index() == 0)
  7345		{
  7346		  if (__y._M_inner_it.index() == 0)
  7347		    ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
  7348		  else
  7349		    ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
  7350		}
  7351	      else
  7352		{
  7353		  if (__y._M_inner_it.index() == 0)
  7354		    ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
  7355		  else
  7356		    ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
  7357		}
  7358	    }
  7359	  };
  7360	
  7361	  template<input_range _Vp, forward_range _Pattern>
  7362	    requires view<_Vp> && view<_Pattern>
  7363	      && input_range<range_reference_t<_Vp>>
  7364	      && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
  7365	  template<bool _Const>
  7366	  class join_with_view<_Vp, _Pattern>::_Sentinel
  7367	  {
  7368	    using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
  7369	    using _Base = join_with_view::_Base<_Const>;
  7370	
  7371	    sentinel_t<_Base> _M_end = sentinel_t<_Base>();
  7372	
  7373	    constexpr explicit
  7374	    _Sentinel(_Parent& __parent)
  7375	    : _M_end(ranges::end(__parent._M_base))
  7376	    { }
  7377	
  7378	    friend join_with_view;
  7379	
  7380	  public:
  7381	    _Sentinel() = default;
  7382	
  7383	    constexpr
  7384	    _Sentinel(_Sentinel<!_Const> __s)
  7385	      requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
  7386	    : _M_end(std::move(__s._M_end))
  7387	    { }
  7388	
  7389	    template<bool _OtherConst>
  7390	      requires sentinel_for<sentinel_t<_Base>,
  7391				    iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
  7392	    friend constexpr bool
  7393	    operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
  7394	    { return __x._M_outer_it == __y._M_end; }
  7395	  };
  7396	
  7397	  namespace views
  7398	  {
  7399	    namespace __detail
  7400	    {
  7401	      template<typename _Range, typename _Pattern>
  7402		concept __can_join_with_view
  7403		  = requires { join_with_view(std::declval<_Range>(), std::declval<_Pattern>()); };
  7404	    } // namespace __detail
  7405	
  7406	    struct _JoinWith : __adaptor::_RangeAdaptor<_JoinWith>
  7407	    {
  7408	      template<viewable_range _Range, typename _Pattern>
  7409		requires __detail::__can_join_with_view<_Range, _Pattern>
  7410		constexpr auto
  7411		operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
  7412		{
  7413		  return join_with_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
  7414		}
  7415	
  7416	      using _RangeAdaptor<_JoinWith>::operator();
  7417	      static constexpr int _S_arity = 2;
  7418	      template<typename _Pattern>
  7419		static constexpr bool _S_has_simple_extra_args
  7420		  = _LazySplit::_S_has_simple_extra_args<_Pattern>;
  7421	    };
  7422	
  7423	    inline constexpr _JoinWith join_with;
  7424	  } // namespace views
  7425	
  7426	#define __cpp_lib_ranges_repeat 202207L
  7427	
  7428	  template<copy_constructible _Tp, semiregular _Bound = unreachable_sentinel_t>
  7429	    requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
  7430	      && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
  7431	  class repeat_view : public view_interface<repeat_view<_Tp, _Bound>>
  7432	  {
  7433	    __detail::__box<_Tp> _M_value;
  7434	    [[no_unique_address]] _Bound _M_bound = _Bound();
  7435	
  7436	    struct _Iterator;
  7437	
  7438	    template<typename _Range>
  7439	    friend constexpr auto
  7440	    views::__detail::__take_of_repeat_view(_Range&&, range_difference_t<_Range>);
  7441	
  7442	    template<typename _Range>
  7443	    friend constexpr auto
  7444	    views::__detail::__drop_of_repeat_view(_Range&&, range_difference_t<_Range>);
  7445	
  7446	  public:
  7447	    repeat_view() requires default_initializable<_Tp> = default;
  7448	
  7449	    constexpr explicit
  7450	    repeat_view(const _Tp& __value, _Bound __bound = _Bound())
  7451	    : _M_value(__value), _M_bound(__bound)
  7452	    {
  7453	      if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
  7454		__glibcxx_assert(__bound >= 0);
  7455	    }
  7456	
  7457	    constexpr explicit
  7458	    repeat_view(_Tp&& __value, _Bound __bound = _Bound())
  7459	    : _M_value(std::move(__value)), _M_bound(__bound)
  7460	    { }
  7461	
  7462	    template<typename... _Args, typename... _BoundArgs>
  7463	      requires constructible_from<_Tp, _Args...>
  7464	        && constructible_from<_Bound, _BoundArgs...>
  7465	    constexpr explicit
  7466	    repeat_view(piecewise_construct_t,
  7467			tuple<_Args...> __args,
  7468			tuple<_BoundArgs...> __bound_args = tuple<>{})
  7469	    : _M_value(std::make_from_tuple<_Tp>(std::move(__args))),
  7470	      _M_bound(std::make_from_tuple<_Bound>(std::move(__bound_args)))
  7471	    { }
  7472	
  7473	    constexpr _Iterator
  7474	    begin() const
  7475	    { return _Iterator(std::__addressof(*_M_value)); }
  7476	
  7477	    constexpr _Iterator
  7478	    end() const requires (!same_as<_Bound, unreachable_sentinel_t>)
  7479	    { return _Iterator(std::__addressof(*_M_value), _M_bound); }
  7480	
  7481	    constexpr unreachable_sentinel_t
  7482	    end() const noexcept
  7483	    { return unreachable_sentinel; }
  7484	
  7485	    constexpr auto
  7486	    size() const requires (!same_as<_Bound, unreachable_sentinel_t>)
  7487	    { return __detail::__to_unsigned_like(_M_bound); }
  7488	  };
  7489	
  7490	  template<typename _Tp, typename _Bound>
  7491	    repeat_view(_Tp, _Bound) -> repeat_view<_Tp, _Bound>;
  7492	
  7493	  template<copy_constructible _Tp, semiregular _Bound>
  7494	    requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
  7495	      && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
  7496	  class repeat_view<_Tp, _Bound>::_Iterator
  7497	  {
  7498	    using __index_type
  7499	      = __conditional_t<same_as<_Bound, unreachable_sentinel_t>, ptrdiff_t, _Bound>;
  7500	
  7501	    const _Tp* _M_value = nullptr;
  7502	    __index_type _M_current = __index_type();
  7503	
  7504	    constexpr explicit
  7505	    _Iterator(const _Tp* __value, __index_type __bound = __index_type())
  7506	    : _M_value(__value), _M_current(__bound)
  7507	    {
  7508	      if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
  7509		__glibcxx_assert(__bound >= 0);
  7510	    }
  7511	
  7512	    friend repeat_view;
  7513	
  7514	  public:
  7515	    using iterator_concept = random_access_iterator_tag;
  7516	    using iterator_category = random_access_iterator_tag;
  7517	    using value_type = _Tp;
  7518	    using difference_type = __conditional_t<__detail::__is_signed_integer_like<__index_type>,
  7519						    __index_type,
  7520						    __detail::__iota_diff_t<__index_type>>;
  7521	
  7522	    _Iterator() = default;
  7523	
  7524	    constexpr const _Tp&
  7525	    operator*() const noexcept
  7526	    { return *_M_value; }
  7527	
  7528	    constexpr _Iterator&
  7529	    operator++()
  7530	    {
  7531	      ++_M_current;
  7532	      return *this;
  7533	    }
  7534	
  7535	    constexpr _Iterator
  7536	    operator++(int)
  7537	    {
  7538	      auto __tmp = *this;
  7539	      ++*this;
  7540	      return __tmp;
  7541	    }
  7542	
  7543	    constexpr _Iterator&
  7544	    operator--()
  7545	    {
  7546	      if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
  7547		__glibcxx_assert(_M_current > 0);
  7548	      --_M_current;
  7549	      return *this;
  7550	    }
  7551	
  7552	    constexpr _Iterator
  7553	    operator--(int)
  7554	    {
  7555	      auto __tmp = *this;
  7556	      --*this;
  7557	      return __tmp;
  7558	    }
  7559	
  7560	    constexpr _Iterator&
  7561	    operator+=(difference_type __n)
  7562	    {
  7563	      if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
  7564		__glibcxx_assert(_M_current + __n >= 0);
  7565	      _M_current += __n;
  7566	      return *this;
  7567	    }
  7568	
  7569	    constexpr _Iterator&
  7570	    operator-=(difference_type __n)
  7571	    {
  7572	      if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
  7573		__glibcxx_assert(_M_current - __n >= 0);
  7574	      _M_current -= __n;
  7575	      return *this;
  7576	    }
  7577	
  7578	    constexpr const _Tp&
  7579	    operator[](difference_type __n) const noexcept
  7580	    { return *(*this + __n); }
  7581	
  7582	    friend constexpr bool
  7583	    operator==(const _Iterator& __x, const _Iterator& __y)
  7584	    { return __x._M_current == __y._M_current; }
  7585	
  7586	    friend constexpr auto
  7587	    operator<=>(const _Iterator& __x, const _Iterator& __y)
  7588	    { return __x._M_current <=> __y._M_current; }
  7589	
  7590	    friend constexpr _Iterator
  7591	    operator+(_Iterator __i, difference_type __n)
  7592	    {
  7593	      __i += __n;
  7594	      return __i;
  7595	    }
  7596	
  7597	    friend constexpr _Iterator
  7598	    operator+(difference_type __n, _Iterator __i)
  7599	    { return __i + __n; }
  7600	
  7601	    friend constexpr _Iterator
  7602	    operator-(_Iterator __i, difference_type __n)
  7603	    {
  7604	      __i -= __n;
  7605	      return __i;
  7606	    }
  7607	
  7608	    friend constexpr difference_type
  7609	    operator-(const _Iterator& __x, const _Iterator& __y)
  7610	    {
  7611	      return (static_cast<difference_type>(__x._M_current)
  7612		      - static_cast<difference_type>(__y._M_current));
  7613	    }
  7614	  };
  7615	
  7616	  namespace views
  7617	  {
  7618	    namespace __detail
  7619	    {
  7620	      template<typename _Tp, typename _Bound>
  7621		inline constexpr bool __is_repeat_view<repeat_view<_Tp, _Bound>> = true;
  7622	
  7623	      template<typename _Tp>
  7624		concept __can_repeat_view
  7625		  = requires { repeat_view(std::declval<_Tp>()); };
  7626	
  7627	      template<typename _Tp, typename _Bound>
  7628		concept __can_bounded_repeat_view
  7629		  = requires { repeat_view(std::declval<_Tp>(), std::declval<_Bound>()); };
  7630	    }
  7631	
  7632	    struct _Repeat
  7633	    {
  7634	      template<typename _Tp>
  7635		requires __detail::__can_repeat_view<_Tp>
  7636	      constexpr auto
  7637	      operator() [[nodiscard]] (_Tp&& __value) const
  7638	      { return repeat_view(std::forward<_Tp>(__value)); }
  7639	
  7640	      template<typename _Tp, typename _Bound>
  7641		requires __detail::__can_bounded_repeat_view<_Tp, _Bound>
  7642	      constexpr auto
  7643	      operator() [[nodiscard]] (_Tp&& __value, _Bound __bound) const
  7644	      { return repeat_view(std::forward<_Tp>(__value), __bound); }
  7645	    };
  7646	
  7647	    inline constexpr _Repeat repeat;
  7648	
  7649	    namespace __detail
  7650	    {
  7651	      template<typename _Range>
  7652		constexpr auto
  7653		__take_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
  7654		{
  7655		  using _Tp = remove_cvref_t<_Range>;
  7656		  static_assert(__is_repeat_view<_Tp>);
  7657		  if constexpr (sized_range<_Tp>)
  7658		    return views::repeat(*__r._M_value, std::min(ranges::distance(__r), __n));
  7659		  else
  7660		    return views::repeat(*__r._M_value, __n);
  7661		}
  7662	
  7663	      template<typename _Range>
  7664		constexpr auto
  7665		__drop_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
  7666		{
  7667		  using _Tp = remove_cvref_t<_Range>;
  7668		  static_assert(__is_repeat_view<_Tp>);
  7669		  if constexpr (sized_range<_Tp>)
  7670		    {
  7671		      auto __sz = ranges::distance(__r);
  7672		      return views::repeat(*__r._M_value, __sz - std::min(__sz, __n));
  7673		    }
  7674		  else
  7675		    return __r;
  7676		}
  7677	    }
  7678	  }
  7679	
  7680	#define __cpp_lib_ranges_stride 202207L
  7681	
  7682	  template<input_range _Vp>
  7683	    requires view<_Vp>
  7684	  class stride_view : public view_interface<stride_view<_Vp>>
  7685	  {
  7686	    _Vp _M_base;
  7687	    range_difference_t<_Vp> _M_stride;
  7688	
  7689	    template<bool _Const> using _Base = __detail::__maybe_const_t<_Const, _Vp>;
  7690	
  7691	    template<bool _Const>
  7692	    struct __iter_cat
  7693	    { };
  7694	
  7695	    template<bool _Const>
  7696	      requires forward_range<_Base<_Const>>
  7697	    struct __iter_cat<_Const>
  7698	    {
  7699	    private:
  7700	      static auto
  7701	      _S_iter_cat()
  7702	      {
  7703		using _Cat = typename iterator_traits<iterator_t<_Base<_Const>>>::iterator_category;
  7704		if constexpr (derived_from<_Cat, random_access_iterator_tag>)
  7705		  return random_access_iterator_tag{};
  7706		else
  7707		  return _Cat{};
  7708	      }
  7709	    public:
  7710	      using iterator_category = decltype(_S_iter_cat());
  7711	    };
  7712	
  7713	    template<bool> class _Iterator;
  7714	
  7715	  public:
  7716	    constexpr explicit
  7717	    stride_view(_Vp __base, range_difference_t<_Vp> __stride)
  7718	    : _M_base(std::move(__base)), _M_stride(__stride)
  7719	    { __glibcxx_assert(__stride > 0); }
  7720	
  7721	    constexpr _Vp
  7722	    base() const& requires copy_constructible<_Vp>
  7723	    { return _M_base; }
  7724	
  7725	    constexpr _Vp
  7726	    base() &&
  7727	    { return std::move(_M_base); }
  7728	
  7729	    constexpr range_difference_t<_Vp>
  7730	    stride() const noexcept
  7731	    { return _M_stride; }
  7732	
  7733	    constexpr auto
  7734	    begin() requires (!__detail::__simple_view<_Vp>)
  7735	    { return _Iterator<false>(this, ranges::begin(_M_base)); }
  7736	
  7737	    constexpr auto
  7738	    begin() const requires range<const _Vp>
  7739	    { return _Iterator<true>(this, ranges::begin(_M_base)); }
  7740	
  7741	    constexpr auto
  7742	    end() requires (!__detail::__simple_view<_Vp>)
  7743	    {
  7744	      if constexpr (common_range<_Vp> && sized_range<_Vp> && forward_range<_Vp>)
  7745		{
  7746		  auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
  7747		  return _Iterator<false>(this, ranges::end(_M_base), __missing);
  7748		}
  7749	      else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
  7750		return _Iterator<false>(this, ranges::end(_M_base));
  7751	      else
  7752	        return default_sentinel;
  7753	    }
  7754	
  7755	    constexpr auto
  7756	    end() const requires range<const _Vp>
  7757	    {
  7758	      if constexpr (common_range<const _Vp> && sized_range<const _Vp>
  7759			    && forward_range<const _Vp>)
  7760		{
  7761		  auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
  7762		  return _Iterator<true>(this, ranges::end(_M_base), __missing);
  7763		}
  7764	      else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
  7765	        return _Iterator<true>(this, ranges::end(_M_base));
  7766	      else
  7767	        return default_sentinel;
  7768	    }
  7769	
  7770	    constexpr auto
  7771	    size() requires sized_range<_Vp>
  7772	    {
  7773	      return __detail::__to_unsigned_like
  7774		(__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
  7775	    }
  7776	
  7777	    constexpr auto
  7778	    size() const requires sized_range<const _Vp>
  7779	    {
  7780	      return __detail::__to_unsigned_like
  7781		(__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
  7782	    }
  7783	  };
  7784	
  7785	  template<typename _Range>
  7786	    stride_view(_Range&&, range_difference_t<_Range>) -> stride_view<views::all_t<_Range>>;
  7787	
  7788	  template<typename _Vp>
  7789	    inline constexpr bool enable_borrowed_range<stride_view<_Vp>>
  7790	      = enable_borrowed_range<_Vp>;
  7791	
  7792	  template<input_range _Vp>
  7793	    requires view<_Vp>
  7794	  template<bool _Const>
  7795	  class stride_view<_Vp>::_Iterator : public __iter_cat<_Const>
  7796	  {
  7797	    using _Parent = __detail::__maybe_const_t<_Const, stride_view>;
  7798	    using _Base = stride_view::_Base<_Const>;
  7799	
  7800	    iterator_t<_Base> _M_current = iterator_t<_Base>();
  7801	    sentinel_t<_Base> _M_end = sentinel_t<_Base>();
  7802	    range_difference_t<_Base> _M_stride = 0;
  7803	    range_difference_t<_Base> _M_missing = 0;
  7804	
  7805	    constexpr
  7806	    _Iterator(_Parent* __parent, iterator_t<_Base> __current,
  7807		      range_difference_t<_Base> __missing = 0)
  7808	    : _M_current(std::move(__current)), _M_end(ranges::end(__parent->_M_base)),
  7809	      _M_stride(__parent->_M_stride), _M_missing(__missing)
  7810	    { }
  7811	
  7812	    static auto
  7813	    _S_iter_concept()
  7814	    {
  7815	      if constexpr (random_access_range<_Base>)
  7816		return random_access_iterator_tag{};
  7817	      else if constexpr (bidirectional_range<_Base>)
  7818		return bidirectional_iterator_tag{};
  7819	      else if constexpr (forward_range<_Base>)
  7820		return forward_iterator_tag{};
  7821	      else
  7822		return input_iterator_tag{};
  7823	    }
  7824	
  7825	    friend stride_view;
  7826	
  7827	  public:
  7828	    using difference_type = range_difference_t<_Base>;
  7829	    using value_type = range_value_t<_Base>;
  7830	    using iterator_concept = decltype(_S_iter_concept());
  7831	    // iterator_category defined in stride_view::__iter_cat
  7832	
  7833	    _Iterator() requires default_initializable<iterator_t<_Base>> = default;
  7834	
  7835	    constexpr
  7836	    _Iterator(_Iterator<!_Const> __other)
  7837	      requires _Const
  7838		&& convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
  7839		&& convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
  7840	     : _M_current(std::move(__other._M_current)), _M_end(std::move(__other._M_end)),
  7841	       _M_stride(__other._M_stride), _M_missing(__other._M_missing)
  7842	     { }
  7843	
  7844	    constexpr iterator_t<_Base>
  7845	    base() &&
  7846	    { return std::move(_M_current); }
  7847	
  7848	    constexpr const iterator_t<_Base>&
  7849	    base() const & noexcept
  7850	    { return _M_current; }
  7851	
  7852	    constexpr decltype(auto)
  7853	    operator*() const
  7854	    { return *_M_current; }
  7855	
  7856	    constexpr _Iterator&
  7857	    operator++()
  7858	    {
  7859	      __glibcxx_assert(_M_current != _M_end);
  7860	      _M_missing = ranges::advance(_M_current, _M_stride, _M_end);
  7861	      return *this;
  7862	    }
  7863	
  7864	    constexpr void
  7865	    operator++(int)
  7866	    { ++*this; }
  7867	
  7868	    constexpr _Iterator
  7869	    operator++(int) requires forward_range<_Base>
  7870	    {
  7871	      auto __tmp = *this;
  7872	      ++*this;
  7873	      return __tmp;
  7874	    }
  7875	
  7876	    constexpr _Iterator&
  7877	    operator--() requires bidirectional_range<_Base>
  7878	    {
  7879	      ranges::advance(_M_current, _M_missing - _M_stride);
  7880	      _M_missing = 0;
  7881	      return *this;
  7882	    }
  7883	
  7884	    constexpr _Iterator
  7885	    operator--(int) requires bidirectional_range<_Base>
  7886	    {
  7887	      auto __tmp = *this;
  7888	      --*this;
  7889	      return __tmp;
  7890	    }
  7891	
  7892	    constexpr _Iterator&
  7893	    operator+=(difference_type __n) requires random_access_range<_Base>
  7894	    {
  7895	      if (__n > 0)
  7896		{
  7897		  __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_stride * (__n - 1));
  7898		  _M_missing = ranges::advance(_M_current, _M_stride * __n, _M_end);
  7899		}
  7900	      else if (__n < 0)
  7901		{
  7902		  ranges::advance(_M_current, _M_stride * __n + _M_missing);
  7903		  _M_missing = 0;
  7904		}
  7905	      return *this;
  7906	    }
  7907	
  7908	    constexpr _Iterator&
  7909	    operator-=(difference_type __n) requires random_access_range<_Base>
  7910	    { return *this += -__n; }
  7911	
  7912	    constexpr decltype(auto) operator[](difference_type __n) const
  7913	      requires random_access_range<_Base>
  7914	    { return *(*this + __n); }
  7915	
  7916	    friend constexpr bool
  7917	    operator==(const _Iterator& __x, default_sentinel_t)
  7918	    { return __x._M_current == __x._M_end; }
  7919	
  7920	    friend constexpr bool
  7921	    operator==(const _Iterator& __x, const _Iterator& __y)
  7922	      requires equality_comparable<iterator_t<_Base>>
  7923	    { return __x._M_current == __y._M_current; }
  7924	
  7925	    friend constexpr bool
  7926	    operator<(const _Iterator& __x, const _Iterator& __y)
  7927	      requires random_access_range<_Base>
  7928	    { return __x._M_current < __y._M_current; }
  7929	
  7930	    friend constexpr bool
  7931	    operator>(const _Iterator& __x, const _Iterator& __y)
  7932	      requires random_access_range<_Base>
  7933	    { return __y._M_current < __x._M_current; }
  7934	
  7935	    friend constexpr bool
  7936	    operator<=(const _Iterator& __x, const _Iterator& __y)
  7937	      requires random_access_range<_Base>
  7938	    { return !(__y._M_current < __x._M_current); }
  7939	
  7940	    friend constexpr bool
  7941	    operator>=(const _Iterator& __x, const _Iterator& __y)
  7942	      requires random_access_range<_Base>
  7943	    { return !(__x._M_current < __y._M_current); }
  7944	
  7945	    friend constexpr auto
  7946	    operator<=>(const _Iterator& __x, const _Iterator& __y)
  7947	        requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
  7948	    { return __x._M_current <=> __y._M_current; }
  7949	
  7950	    friend constexpr _Iterator
  7951	    operator+(const _Iterator& __i, difference_type __n)
  7952	      requires random_access_range<_Base>
  7953	    {
  7954	      auto __r = __i;
  7955	      __r += __n;
  7956	      return __r;
  7957	    }
  7958	
  7959	    friend constexpr _Iterator
  7960	    operator+(difference_type __n, const _Iterator& __i)
  7961	      requires random_access_range<_Base>
  7962	    { return __i + __n; }
  7963	
  7964	    friend constexpr _Iterator
  7965	    operator-(const _Iterator& __i, difference_type __n)
  7966	      requires random_access_range<_Base>
  7967	    {
  7968	      auto __r = __i;
  7969	      __r -= __n;
  7970	      return __r;
  7971	    }
  7972	
  7973	    friend constexpr difference_type
  7974	    operator-(const _Iterator& __x, const _Iterator& __y)
  7975	      requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
  7976	    {
  7977	      auto __n = __x._M_current - __y._M_current;
  7978	      if constexpr (forward_range<_Base>)
  7979		return (__n + __x._M_missing - __y._M_missing) / __x._M_stride;
  7980	      else if (__n < 0)
  7981		return -__detail::__div_ceil(-__n, __x._M_stride);
  7982	      else
  7983		return __detail::__div_ceil(__n, __x._M_stride);
  7984	    }
  7985	
  7986	    friend constexpr difference_type
  7987	    operator-(default_sentinel_t __y, const _Iterator& __x)
  7988	      requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
  7989	    { return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_stride); }
  7990	
  7991	    friend constexpr difference_type
  7992	    operator-(const _Iterator& __x, default_sentinel_t __y)
  7993	      requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
  7994	    { return -(__y - __x); }
  7995	
  7996	    friend constexpr range_rvalue_reference_t<_Base>
  7997	    iter_move(const _Iterator& __i)
  7998	      noexcept(noexcept(ranges::iter_move(__i._M_current)))
  7999	    { return ranges::iter_move(__i._M_current); }
  8000	
  8001	    friend constexpr void
  8002	    iter_swap(const _Iterator& __x, const _Iterator& __y)
  8003	      noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
  8004	      requires indirectly_swappable<iterator_t<_Base>>
  8005	    { ranges::iter_swap(__x._M_current, __y._M_current); }
  8006	  };
  8007	
  8008	  namespace views
  8009	  {
  8010	    namespace __detail
  8011	    {
  8012	      template<typename _Range, typename _Dp>
  8013		concept __can_stride_view
  8014		  = requires { stride_view(std::declval<_Range>(), std::declval<_Dp>()); };
  8015	    }
  8016	
  8017	    struct _Stride : __adaptor::_RangeAdaptor<_Stride>
  8018	    {
  8019	      template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
  8020		requires __detail::__can_stride_view<_Range, _Dp>
  8021		constexpr auto
  8022		operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
  8023		{ return stride_view(std::forward<_Range>(__r), __n); }
  8024	
  8025	      using __adaptor::_RangeAdaptor<_Stride>::operator();
  8026	      static constexpr int _S_arity = 2;
  8027	      static constexpr bool _S_has_simple_extra_args = true;
  8028	    };
  8029	
  8030	    inline constexpr _Stride stride;
  8031	  }
  8032	
  8033	#define __cpp_lib_ranges_cartesian_product 202207L
  8034	
  8035	  namespace __detail
  8036	  {
  8037	    template<bool _Const, typename _First, typename... _Vs>
  8038	      concept __cartesian_product_is_random_access
  8039		= (random_access_range<__maybe_const_t<_Const, _First>>
  8040		   && ...
  8041		   && (random_access_range<__maybe_const_t<_Const, _Vs>>
  8042		       && sized_range<__maybe_const_t<_Const, _Vs>>));
  8043	
  8044	    template<typename _Range>
  8045	      concept __cartesian_product_common_arg
  8046		= common_range<_Range> || (sized_range<_Range> && random_access_range<_Range>);
  8047	
  8048	    template<bool _Const, typename _First, typename... _Vs>
  8049	      concept __cartesian_product_is_bidirectional
  8050		= (bidirectional_range<__maybe_const_t<_Const, _First>>
  8051		   && ...
  8052		   && (bidirectional_range<__maybe_const_t<_Const, _Vs>>
  8053		       && __cartesian_product_common_arg<__maybe_const_t<_Const, _Vs>>));
  8054	
  8055	    template<typename _First, typename... _Vs>
  8056	      concept __cartesian_product_is_common = __cartesian_product_common_arg<_First>;
  8057	
  8058	    template<typename... _Vs>
  8059	      concept __cartesian_product_is_sized = (sized_range<_Vs> && ...);
  8060	
  8061	    template<bool _Const, template<typename> class FirstSent, typename _First, typename... _Vs>
  8062	      concept __cartesian_is_sized_sentinel
  8063		= (sized_sentinel_for<FirstSent<__maybe_const_t<_Const, _First>>,
  8064				      iterator_t<__maybe_const_t<_Const, _First>>>
  8065		   && ...
  8066		   && (sized_range<__maybe_const_t<_Const, _Vs>>
  8067		       && sized_sentinel_for<iterator_t<__maybe_const_t<_Const, _Vs>>,
  8068					     iterator_t<__maybe_const_t<_Const, _Vs>>>));
  8069	
  8070	    template<__cartesian_product_common_arg _Range>
  8071	      constexpr auto
  8072	      __cartesian_common_arg_end(_Range& __r)
  8073	      {
  8074		if constexpr (common_range<_Range>)
  8075		  return ranges::end(__r);
  8076		else
  8077		  return ranges::begin(__r) + ranges::distance(__r);
  8078	      }
  8079	  } // namespace __detail
  8080	
  8081	  template<input_range _First, forward_range... _Vs>
  8082	    requires (view<_First> && ... && view<_Vs>)
  8083	  class cartesian_product_view : public view_interface<cartesian_product_view<_First, _Vs...>>
  8084	  {
  8085	    tuple<_First, _Vs...> _M_bases;
  8086	
  8087	    template<bool> class _Iterator;
  8088	
  8089	    static auto
  8090	    _S_difference_type()
  8091	    {
  8092	      // TODO: Implement the recommended practice of using the smallest
  8093	      // sufficiently wide type according to the maximum sizes of the
  8094	      // underlying ranges?
  8095	      return common_type_t<ptrdiff_t,
  8096				   range_difference_t<_First>,
  8097				   range_difference_t<_Vs>...>{};
  8098	    }
  8099	
  8100	  public:
  8101	    cartesian_product_view() = default;
  8102	
  8103	    constexpr explicit
  8104	    cartesian_product_view(_First __first, _Vs... __rest)
  8105	    : _M_bases(std::move(__first), std::move(__rest)...)
  8106	    { }
  8107	
  8108	    constexpr _Iterator<false>
  8109	    begin() requires (!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
  8110	    { return _Iterator<false>(*this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
  8111	
  8112	    constexpr _Iterator<true>
  8113	    begin() const requires (range<const _First> && ... && range<const _Vs>)
  8114	    { return _Iterator<true>(*this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
  8115	
  8116	    constexpr _Iterator<false>
  8117	    end() requires ((!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
  8118			    && __detail::__cartesian_product_is_common<_First, _Vs...>)
  8119	    {
  8120	      auto __its = [this]<size_t... _Is>(index_sequence<_Is...>) {
  8121		using _Ret = __detail::__tuple_or_pair_t<iterator_t<_First>,
  8122							 iterator_t<_Vs>...>;
  8123		bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
  8124		auto& __first = std::get<0>(_M_bases);
  8125		return _Ret{(__empty_tail
  8126			     ? ranges::begin(__first)
  8127			     : __detail::__cartesian_common_arg_end(__first)),
  8128			    ranges::begin(std::get<1 + _Is>(_M_bases))...};
  8129	      }(make_index_sequence<sizeof...(_Vs)>{});
  8130	
  8131	      return _Iterator<false>{*this, std::move(__its)};
  8132	    }
  8133	
  8134	    constexpr _Iterator<true>
  8135	    end() const requires __detail::__cartesian_product_is_common<const _First, const _Vs...>
  8136	    {
  8137	      auto __its = [this]<size_t... _Is>(index_sequence<_Is...>) {
  8138		using _Ret = __detail::__tuple_or_pair_t<iterator_t<const _First>,
  8139							 iterator_t<const _Vs>...>;
  8140		bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
  8141		auto& __first = std::get<0>(_M_bases);
  8142		return _Ret{(__empty_tail
  8143			     ? ranges::begin(__first)
  8144			     : __detail::__cartesian_common_arg_end(__first)),
  8145			    ranges::begin(std::get<1 + _Is>(_M_bases))...};
  8146	      }(make_index_sequence<sizeof...(_Vs)>{});
  8147	
  8148	      return _Iterator<true>{*this, std::move(__its)};
  8149	    }
  8150	
  8151	    constexpr default_sentinel_t
  8152	    end() const noexcept
  8153	    { return default_sentinel; }
  8154	
  8155	    constexpr auto
  8156	    size() requires __detail::__cartesian_product_is_sized<_First, _Vs...>
  8157	    {
  8158	      using _ST = __detail::__make_unsigned_like_t<decltype(_S_difference_type())>;
  8159	      return [&]<size_t... _Is>(index_sequence<_Is...>) {
  8160		auto __size = static_cast<_ST>(1);
  8161	#ifdef _GLIBCXX_ASSERTIONS
  8162		if constexpr (integral<_ST>)
  8163		  {
  8164		    bool __overflow
  8165		      = (__builtin_mul_overflow(__size,
  8166						static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))),
  8167						&__size)
  8168			 || ...);
  8169		    __glibcxx_assert(!__overflow);
  8170		  }
  8171		else
  8172	#endif
  8173		  __size = (static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))) * ...);
  8174		return __size;
  8175	      }(make_index_sequence<1 + sizeof...(_Vs)>{});
  8176	    }
  8177	
  8178	    constexpr auto
  8179	    size() const requires __detail::__cartesian_product_is_sized<const _First, const _Vs...>
  8180	    {
  8181	      using _ST = __detail::__make_unsigned_like_t<decltype(_S_difference_type())>;
  8182	      return [&]<size_t... _Is>(index_sequence<_Is...>) {
  8183		auto __size = static_cast<_ST>(1);
  8184	#ifdef _GLIBCXX_ASSERTIONS
  8185		if constexpr (integral<_ST>)
  8186		  {
  8187		    bool __overflow
  8188		      = (__builtin_mul_overflow(__size,
  8189						static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))),
  8190						&__size)
  8191			 || ...);
  8192		    __glibcxx_assert(!__overflow);
  8193		  }
  8194		else
  8195	#endif
  8196		  __size = (static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))) * ...);
  8197		return __size;
  8198	      }(make_index_sequence<1 + sizeof...(_Vs)>{});
  8199	    }
  8200	  };
  8201	
  8202	  template<typename... _Vs>
  8203	    cartesian_product_view(_Vs&&...) -> cartesian_product_view<views::all_t<_Vs>...>;
  8204	
  8205	  template<input_range _First, forward_range... _Vs>
  8206	    requires (view<_First> && ... && view<_Vs>)
  8207	  template<bool _Const>
  8208	  class cartesian_product_view<_First, _Vs...>::_Iterator
  8209	  {
  8210	    using _Parent = __maybe_const_t<_Const, cartesian_product_view>;
  8211	    _Parent* _M_parent = nullptr;
  8212	    __detail::__tuple_or_pair_t<iterator_t<__maybe_const_t<_Const, _First>>,
  8213					iterator_t<__maybe_const_t<_Const, _Vs>>...> _M_current;
  8214	
  8215	    constexpr
  8216	    _Iterator(_Parent& __parent, decltype(_M_current) __current)
  8217	    : _M_parent(std::__addressof(__parent)),
  8218	      _M_current(std::move(__current))
  8219	    { }
  8220	
  8221	    static auto
  8222	    _S_iter_concept()
  8223	    {
  8224	      if constexpr (__detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>)
  8225		return random_access_iterator_tag{};
  8226	      else if constexpr (__detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>)
  8227		return bidirectional_iterator_tag{};
  8228	      else if constexpr (forward_range<__maybe_const_t<_Const, _First>>)
  8229		return forward_iterator_tag{};
  8230	      else
  8231		return input_iterator_tag{};
  8232	    }
  8233	
  8234	    friend cartesian_product_view;
  8235	
  8236	  public:
  8237	    using iterator_category = input_iterator_tag;
  8238	    using iterator_concept = decltype(_S_iter_concept());
  8239	    using value_type
  8240	      = __detail::__tuple_or_pair_t<range_value_t<__maybe_const_t<_Const, _First>>,
  8241					    range_value_t<__maybe_const_t<_Const, _Vs>>...>;
  8242	    using reference
  8243	      = __detail::__tuple_or_pair_t<range_reference_t<__maybe_const_t<_Const, _First>>,
  8244					    range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
  8245	    using difference_type = decltype(cartesian_product_view::_S_difference_type());
  8246	
  8247	    _Iterator() = default;
  8248	
  8249	    constexpr
  8250	    _Iterator(_Iterator<!_Const> __i)
  8251	      requires _Const
  8252		&& (convertible_to<iterator_t<_First>, iterator_t<const _First>>
  8253		    && ... && convertible_to<iterator_t<_Vs>, iterator_t<const _Vs>>)
  8254	    : _M_parent(std::__addressof(__i._M_parent)),
  8255	      _M_current(std::move(__i._M_current))
  8256	    { }
  8257	
  8258	    constexpr auto
  8259	    operator*() const
  8260	    {
  8261	      auto __f = [](auto& __i) -> decltype(auto) {
  8262		return *__i;
  8263	      };
  8264	      return __detail::__tuple_transform(__f, _M_current);
  8265	    }
  8266	
  8267	    constexpr _Iterator&
  8268	    operator++()
  8269	    {
  8270	      _M_next();
  8271	      return *this;
  8272	    }
  8273	
  8274	    constexpr void
  8275	    operator++(int)
  8276	    { ++*this; }
  8277	
  8278	    constexpr _Iterator
  8279	    operator++(int) requires forward_range<__maybe_const_t<_Const, _First>>
  8280	    {
  8281	      auto __tmp = *this;
  8282	      ++*this;
  8283	      return __tmp;
  8284	    }
  8285	
  8286	    constexpr _Iterator&
  8287	    operator--()
  8288	      requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
  8289	    {
  8290	      _M_prev();
  8291	      return *this;
  8292	    }
  8293	
  8294	    constexpr _Iterator
  8295	    operator--(int)
  8296	      requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
  8297	    {
  8298	      auto __tmp = *this;
  8299	      --*this;
  8300	      return __tmp;
  8301	    }
  8302	
  8303	    constexpr _Iterator&
  8304	    operator+=(difference_type __x)
  8305	      requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
  8306	    {
  8307	      _M_advance(__x);
  8308	      return *this;
  8309	    }
  8310	
  8311	    constexpr _Iterator&
  8312	    operator-=(difference_type __x)
  8313	      requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
  8314	    { return *this += -__x; }
  8315	
  8316	    constexpr reference
  8317	    operator[](difference_type __n) const
  8318	      requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
  8319	    { return *((*this) + __n); }
  8320	
  8321	    friend constexpr bool
  8322	    operator==(const _Iterator& __x, const _Iterator& __y)
  8323	      requires equality_comparable<iterator_t<__maybe_const_t<_Const, _First>>>
  8324	    { return __x._M_current == __y._M_current; }
  8325	
  8326	    friend constexpr bool
  8327	    operator==(const _Iterator& __x, default_sentinel_t)
  8328	    {
  8329	      return [&]<size_t... _Is>(index_sequence<_Is...>) {
  8330		return ((std::get<_Is>(__x._M_current)
  8331			 == ranges::end(std::get<_Is>(__x._M_parent->_M_bases)))
  8332			|| ...);
  8333	      }(make_index_sequence<1 + sizeof...(_Vs)>{});
  8334	    }
  8335	
  8336	    friend constexpr auto
  8337	    operator<=>(const _Iterator& __x, const _Iterator& __y)
  8338	      requires __detail::__all_random_access<_Const, _First, _Vs...>
  8339	    { return __x._M_current <=> __y._M_current; }
  8340	
  8341	    friend constexpr _Iterator
  8342	    operator+(_Iterator __x, difference_type __y)
  8343	      requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
  8344	    { return __x += __y; }
  8345	
  8346	    friend constexpr _Iterator
  8347	    operator+(difference_type __x, _Iterator __y)
  8348	      requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
  8349	    { return __y += __x; }
  8350	
  8351	    friend constexpr _Iterator
  8352	    operator-(_Iterator __x, difference_type __y)
  8353	      requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
  8354	    { return __x -= __y; }
  8355	
  8356	    friend constexpr difference_type
  8357	    operator-(const _Iterator& __x, const _Iterator& __y)
  8358	      requires __detail::__cartesian_is_sized_sentinel<_Const, iterator_t, _First, _Vs...>
  8359	    { return __x._M_distance_from(__y._M_current); }
  8360	
  8361	    friend constexpr difference_type
  8362	    operator-(const _Iterator& __i, default_sentinel_t)
  8363	      requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
  8364	    {
  8365	      tuple __end_tuple = [&]<size_t... _Is>(index_sequence<_Is...>) {
  8366		return tuple{ranges::end(std::get<0>(__i._M_parent->_M_bases)),
  8367			     ranges::begin(std::get<1 + _Is>(__i._M_parent->_M_bases))...};
  8368	      }(make_index_sequence<sizeof...(_Vs)>{});
  8369	      return __i._M_distance_from(__end_tuple);
  8370	    }
  8371	
  8372	    friend constexpr difference_type
  8373	    operator-(default_sentinel_t, const _Iterator& __i)
  8374	      requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
  8375	    { return -(__i - default_sentinel); }
  8376	
  8377	    friend constexpr auto
  8378	    iter_move(const _Iterator& __i)
  8379	    { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
  8380	
  8381	    friend constexpr void
  8382	    iter_swap(const _Iterator& __l, const _Iterator& __r)
  8383	      requires (indirectly_swappable<iterator_t<__maybe_const_t<_Const, _First>>>
  8384			&& ...
  8385			&& indirectly_swappable<iterator_t<__maybe_const_t<_Const, _Vs>>>)
  8386	    {
  8387	      [&]<size_t... _Is>(index_sequence<_Is...>) {
  8388		(ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
  8389	      }(make_index_sequence<1 + sizeof...(_Vs)>{});
  8390	    }
  8391	
  8392	  private:
  8393	    template<size_t _Nm = sizeof...(_Vs)>
  8394	    constexpr void
  8395	    _M_next()
  8396	    {
  8397	      auto& __it = std::get<_Nm>(_M_current);
  8398	      ++__it;
  8399	      if constexpr (_Nm > 0)
  8400		if (__it == ranges::end(std::get<_Nm>(_M_parent->_M_bases)))
  8401		  {
  8402		    __it = ranges::begin(std::get<_Nm>(_M_parent->_M_bases));
  8403		    _M_next<_Nm - 1>();
  8404		  }
  8405	    }
  8406	
  8407	    template<size_t _Nm = sizeof...(_Vs)>
  8408	    constexpr void
  8409	    _M_prev()
  8410	    {
  8411	      auto& __it = std::get<_Nm>(_M_current);
  8412	      if constexpr (_Nm > 0)
  8413		if (__it == ranges::begin(std::get<_Nm>(_M_parent->_M_bases)))
  8414		  {
  8415		    __it = __detail::__cartesian_common_arg_end(std::get<_Nm>(_M_parent->_M_bases));
  8416		    _M_prev<_Nm - 1>();
  8417		  }
  8418	      --__it;
  8419	    }
  8420	
  8421	    template<size_t _Nm = sizeof...(_Vs)>
  8422	    constexpr void
  8423	    _M_advance(difference_type __x)
  8424	      requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
  8425	    {
  8426	      if (__x == 1)
  8427		_M_next<_Nm>();
  8428	      else if (__x == -1)
  8429		_M_prev<_Nm>();
  8430	      else if (__x != 0)
  8431		{
  8432		  // Constant time iterator advancement.
  8433		  auto& __r = std::get<_Nm>(_M_parent->_M_bases);
  8434		  auto& __it = std::get<_Nm>(_M_current);
  8435		  if constexpr (_Nm == 0)
  8436		    {
  8437	#ifdef _GLIBCXX_ASSERTIONS
  8438		      if constexpr (sized_range<__maybe_const_t<_Const, _First>>)
  8439			{
  8440			  auto __size = ranges::ssize(__r);
  8441			  auto __begin = ranges::begin(__r);
  8442			  auto __offset = __it - __begin;
  8443			  __glibcxx_assert(__offset + __x >= 0 && __offset + __x <= __size);
  8444			}
  8445	#endif
  8446		      __it += __x;
  8447		    }
  8448		  else
  8449		    {
  8450		      auto __size = ranges::ssize(__r);
  8451		      auto __begin = ranges::begin(__r);
  8452		      auto __offset = __it - __begin;
  8453		      __offset += __x;
  8454		      __x = __offset / __size;
  8455		      __offset %= __size;
  8456		      if (__offset < 0)
  8457			{
  8458			  __offset = __size + __offset;
  8459			  --__x;
  8460			}
  8461		      __it = __begin + __offset;
  8462		      _M_advance<_Nm - 1>(__x);
  8463		    }
  8464		}
  8465	    }
  8466	
  8467	    template<typename _Tuple>
  8468	    constexpr difference_type
  8469	    _M_distance_from(const _Tuple& __t) const
  8470	    {
  8471	      return [&]<size_t... _Is>(index_sequence<_Is...>) {
  8472		auto __sum = static_cast<difference_type>(0);
  8473	#ifdef _GLIBCXX_ASSERTIONS
  8474		if constexpr (integral<difference_type>)
  8475		  {
  8476		    bool __overflow
  8477		      = (__builtin_add_overflow(__sum, _M_scaled_distance<_Is>(__t), &__sum)
  8478			 || ...);
  8479		    __glibcxx_assert(!__overflow);
  8480		  }
  8481		else
  8482	#endif
  8483		  __sum = (_M_scaled_distance<_Is>(__t) + ...);
  8484		return __sum;
  8485	      }(make_index_sequence<1 + sizeof...(_Vs)>{});
  8486	    }
  8487	
  8488	    template<size_t _Nm, typename _Tuple>
  8489	    constexpr difference_type
  8490	    _M_scaled_distance(const _Tuple& __t) const
  8491	    {
  8492	      auto __dist = static_cast<difference_type>(std::get<_Nm>(_M_current)
  8493							 - std::get<_Nm>(__t));
  8494	#ifdef _GLIBCXX_ASSERTIONS
  8495	      if constexpr (integral<difference_type>)
  8496		{
  8497		  bool __overflow = __builtin_mul_overflow(__dist, _M_scaled_size<_Nm+1>(), &__dist);
  8498		  __glibcxx_assert(!__overflow);
  8499		}
  8500	      else
  8501	#endif
  8502		__dist *= _M_scaled_size<_Nm+1>();
  8503	      return __dist;
  8504	    }
  8505	
  8506	    template<size_t _Nm>
  8507	    constexpr difference_type
  8508	    _M_scaled_size() const
  8509	    {
  8510	      if constexpr (_Nm <= sizeof...(_Vs))
  8511		{
  8512		  auto __size = static_cast<difference_type>(ranges::size
  8513							     (std::get<_Nm>(_M_parent->_M_bases)));
  8514	#ifdef _GLIBCXX_ASSERTIONS
  8515		  if constexpr (integral<difference_type>)
  8516		    {
  8517		      bool __overflow = __builtin_mul_overflow(__size, _M_scaled_size<_Nm+1>(), &__size);
  8518		      __glibcxx_assert(!__overflow);
  8519		    }
  8520		  else
  8521	#endif
  8522		    __size *= _M_scaled_size<_Nm+1>();
  8523		  return __size;
  8524		}
  8525	      else
  8526		return static_cast<difference_type>(1);
  8527	    }
  8528	  };
  8529	
  8530	  namespace views
  8531	  {
  8532	    namespace __detail
  8533	    {
  8534	      template<typename... _Ts>
  8535		concept __can_cartesian_product_view
  8536		  = requires { cartesian_product_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
  8537	    }
  8538	
  8539	    struct _CartesianProduct
  8540	    {
  8541	      template<typename... _Ts>
  8542		requires (sizeof...(_Ts) == 0 || __detail::__can_cartesian_product_view<_Ts...>)
  8543		constexpr auto
  8544		operator() [[nodiscard]] (_Ts&&... __ts) const
  8545		{
  8546		  if constexpr (sizeof...(_Ts) == 0)
  8547		    return views::empty<tuple<>>;
  8548		  else
  8549		    return cartesian_product_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
  8550		}
  8551	    };
  8552	
  8553	    inline constexpr _CartesianProduct cartesian_product;
  8554	  }
  8555	
  8556	#define __cpp_lib_ranges_as_rvalue 202207L
  8557	
  8558	  template<input_range _Vp>
  8559	    requires view<_Vp>
  8560	  class as_rvalue_view : public view_interface<as_rvalue_view<_Vp>>
  8561	  {
  8562	    _Vp _M_base = _Vp();
  8563	
  8564	  public:
  8565	    as_rvalue_view() requires default_initializable<_Vp> = default;
  8566	
  8567	    constexpr explicit
  8568	    as_rvalue_view(_Vp __base)
  8569	    : _M_base(std::move(__base))
  8570	    { }
  8571	
  8572	    constexpr _Vp
  8573	    base() const& requires copy_constructible<_Vp>
  8574	    { return _M_base; }
  8575	
  8576	    constexpr _Vp
  8577	    base() &&
  8578	    { return std::move(_M_base); }
  8579	
  8580	    constexpr auto
  8581	    begin() requires (!__detail::__simple_view<_Vp>)
  8582	    { return move_iterator(ranges::begin(_M_base)); }
  8583	
  8584	    constexpr auto
  8585	    begin() const requires range<const _Vp>
  8586	    { return move_iterator(ranges::begin(_M_base)); }
  8587	
  8588	    constexpr auto
  8589	    end() requires (!__detail::__simple_view<_Vp>)
  8590	    {
  8591	      if constexpr (common_range<_Vp>)
  8592		return move_iterator(ranges::end(_M_base));
  8593	      else
  8594		return move_sentinel(ranges::end(_M_base));
  8595	    }
  8596	
  8597	    constexpr auto
  8598	    end() const requires range<const _Vp>
  8599	    {
  8600	      if constexpr (common_range<const _Vp>)
  8601		return move_iterator(ranges::end(_M_base));
  8602	      else
  8603		return move_sentinel(ranges::end(_M_base));
  8604	    }
  8605	
  8606	    constexpr auto
  8607	    size() requires sized_range<_Vp>
  8608	    { return ranges::size(_M_base); }
  8609	
  8610	    constexpr auto
  8611	    size() const requires sized_range<const _Vp>
  8612	    { return ranges::size(_M_base); }
  8613	  };
  8614	
  8615	  template<typename _Range>
  8616	    as_rvalue_view(_Range&&) -> as_rvalue_view<views::all_t<_Range>>;
  8617	
  8618	  template<typename _Tp>
  8619	    inline constexpr bool enable_borrowed_range<as_rvalue_view<_Tp>>
  8620	      = enable_borrowed_range<_Tp>;
  8621	
  8622	  namespace views
  8623	  {
  8624	    namespace __detail
  8625	    {
  8626	      template<typename _Tp>
  8627		concept __can_as_rvalue_view = requires { as_rvalue_view(std::declval<_Tp>()); };
  8628	    }
  8629	
  8630	    struct _AsRvalue : __adaptor::_RangeAdaptorClosure
  8631	    {
  8632	      template<viewable_range _Range>
  8633		requires __detail::__can_as_rvalue_view<_Range>
  8634		constexpr auto
  8635		operator() [[nodiscard]] (_Range&& __r) const
  8636		{
  8637		  if constexpr (same_as<range_rvalue_reference_t<_Range>,
  8638					range_reference_t<_Range>>)
  8639		    return views::all(std::forward<_Range>(__r));
  8640		  else
  8641		    return as_rvalue_view(std::forward<_Range>(__r));
  8642		}
  8643	    };
  8644	
  8645	    inline constexpr _AsRvalue as_rvalue;
  8646	  }
  8647	
  8648	#define __cpp_lib_ranges_enumerate 202302L
  8649	
  8650	  namespace __detail
  8651	  {
  8652	    template<typename _Range>
  8653	      concept __range_with_movable_reference = input_range<_Range>
  8654		&& move_constructible<range_reference_t<_Range>>
  8655		&& move_constructible<range_rvalue_reference_t<_Range>>;
  8656	  }
  8657	
  8658	  template<view _Vp>
  8659	    requires __detail::__range_with_movable_reference<_Vp>
  8660	  class enumerate_view : public view_interface<enumerate_view<_Vp>>
  8661	  {
  8662	    _Vp _M_base = _Vp();
  8663	
  8664	    template<bool _Const> class _Iterator;
  8665	    template<bool _Const> class _Sentinel;
  8666	
  8667	  public:
  8668	    enumerate_view() requires default_initializable<_Vp> = default;
  8669	
  8670	    constexpr explicit
  8671	    enumerate_view(_Vp __base)
  8672	    : _M_base(std::move(__base))
  8673	    { }
  8674	
  8675	    constexpr auto
  8676	    begin() requires (!__detail::__simple_view<_Vp>)
  8677	    { return _Iterator<false>(ranges::begin(_M_base), 0); }
  8678	
  8679	    constexpr auto
  8680	    begin() const requires __detail::__range_with_movable_reference<const _Vp>
  8681	    { return _Iterator<true>(ranges::begin(_M_base), 0); }
  8682	
  8683	    constexpr auto
  8684	    end() requires (!__detail::__simple_view<_Vp>)
  8685	    {
  8686	      if constexpr (common_range<_Vp> && sized_range<_Vp>)
  8687		return _Iterator<false>(ranges::end(_M_base), ranges::distance(_M_base));
  8688	      else
  8689		return _Sentinel<false>(ranges::end(_M_base));
  8690	    }
  8691	
  8692	    constexpr auto
  8693	    end() const requires __detail::__range_with_movable_reference<const _Vp>
  8694	    {
  8695	      if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
  8696		return _Iterator<true>(ranges::end(_M_base), ranges::distance(_M_base));
  8697	      else
  8698		return _Sentinel<true>(ranges::end(_M_base));
  8699	    }
  8700	
  8701	    constexpr auto
  8702	    size() requires sized_range<_Vp>
  8703	    { return ranges::size(_M_base); }
  8704	
  8705	    constexpr auto
  8706	    size() const requires sized_range<const _Vp>
  8707	    { return ranges::size(_M_base); }
  8708	
  8709	    constexpr _Vp
  8710	    base() const & requires copy_constructible<_Vp>
  8711	    { return _M_base; }
  8712	
  8713	    constexpr _Vp
  8714	    base() &&
  8715	    { return std::move(_M_base); }
  8716	  };
  8717	
  8718	  template<typename _Range>
  8719	    enumerate_view(_Range&&) -> enumerate_view<views::all_t<_Range>>;
  8720	
  8721	  template<typename _Tp>
  8722	    inline constexpr bool enable_borrowed_range<enumerate_view<_Tp>>
  8723	      = enable_borrowed_range<_Tp>;
  8724	
  8725	  template<view _Vp>
  8726	  requires __detail::__range_with_movable_reference<_Vp>
  8727	  template<bool _Const>
  8728	  class enumerate_view<_Vp>::_Iterator
  8729	  {
  8730	    using _Base = __maybe_const_t<_Const, _Vp>;
  8731	
  8732	    static auto
  8733	    _S_iter_concept()
  8734	    {
  8735	      if constexpr (random_access_range<_Base>)
  8736		return random_access_iterator_tag{};
  8737	      else if constexpr (bidirectional_range<_Base>)
  8738		return bidirectional_iterator_tag{};
  8739	      else if constexpr (forward_range<_Base>)
  8740		return forward_iterator_tag{};
  8741	      else
  8742		return input_iterator_tag{};
  8743	    }
  8744	
  8745	    friend enumerate_view;
  8746	
  8747	  public:
  8748	    using iterator_category = input_iterator_tag;
  8749	    using iterator_concept = decltype(_S_iter_concept());
  8750	    using difference_type = range_difference_t<_Base>;
  8751	    using value_type = tuple<difference_type, range_value_t<_Base>>;
  8752	
  8753	  private:
  8754	    using __reference_type = tuple<difference_type, range_reference_t<_Base>>;
  8755	
  8756	    iterator_t<_Base> _M_current = iterator_t<_Base>();
  8757	    difference_type _M_pos = 0;
  8758	
  8759	    constexpr explicit
  8760	    _Iterator(iterator_t<_Base> __current, difference_type __pos)
  8761	    : _M_current(std::move(__current)), _M_pos(__pos)
  8762	    { }
  8763	
  8764	  public:
  8765	    _Iterator() requires default_initializable<iterator_t<_Base>> = default;
  8766	
  8767	    constexpr
  8768	    _Iterator(_Iterator<!_Const> __i)
  8769	    requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
  8770	    : _M_current(std::move(__i._M_current)), _M_pos(__i._M_pos)
  8771	    { }
  8772	
  8773	    constexpr const iterator_t<_Base> &
  8774	    base() const & noexcept
  8775	    { return _M_current; }
  8776	
  8777	    constexpr iterator_t<_Base>
  8778	    base() &&
  8779	    { return std::move(_M_current); }
  8780	
  8781	    constexpr difference_type
  8782	    index() const noexcept
  8783	    { return _M_pos; }
  8784	
  8785	    constexpr auto
  8786	    operator*() const
  8787	    { return __reference_type(_M_pos, *_M_current); }
  8788	
  8789	    constexpr _Iterator&
  8790	    operator++()
  8791	    {
  8792	      ++_M_current;
  8793	      ++_M_pos;
  8794	      return *this;
  8795	    }
  8796	
  8797	    constexpr void
  8798	    operator++(int)
  8799	    { ++*this; }
  8800	
  8801	    constexpr _Iterator
  8802	    operator++(int) requires forward_range<_Base>
  8803	    {
  8804	      auto __tmp = *this;
  8805	      ++*this;
  8806	      return __tmp;
  8807	    }
  8808	
  8809	    constexpr _Iterator&
  8810	    operator--() requires bidirectional_range<_Base>
  8811	    {
  8812	      --_M_current;
  8813	      --_M_pos;
  8814	      return *this;
  8815	    }
  8816	
  8817	    constexpr _Iterator
  8818	    operator--(int) requires bidirectional_range<_Base>
  8819	    {
  8820	      auto __tmp = *this;
  8821	      --*this;
  8822	      return __tmp;
  8823	    }
  8824	
  8825	    constexpr _Iterator&
  8826	    operator+=(difference_type __n) requires random_access_range<_Base>
  8827	    {
  8828	      _M_current += __n;
  8829	      _M_pos += __n;
  8830	      return *this;
  8831	    }
  8832	
  8833	    constexpr _Iterator&
  8834	    operator-=(difference_type __n) requires random_access_range<_Base>
  8835	    {
  8836	      _M_current -= __n;
  8837	      _M_pos -= __n;
  8838	      return *this;
  8839	    }
  8840	
  8841	    constexpr auto
  8842	    operator[](difference_type __n) const requires random_access_range<_Base>
  8843	    { return __reference_type(_M_pos + __n, _M_current[__n]); }
  8844	
  8845	    friend constexpr bool
  8846	    operator==(const _Iterator& __x, const _Iterator& __y) noexcept
  8847	    { return __x._M_pos == __y._M_pos; }
  8848	
  8849	    friend constexpr strong_ordering
  8850	    operator<=>(const _Iterator& __x, const _Iterator& __y) noexcept
  8851	    { return __x._M_pos <=> __y._M_pos; }
  8852	
  8853	    friend constexpr _Iterator
  8854	    operator+(const _Iterator& __x, difference_type __y)
  8855	    requires random_access_range<_Base>
  8856	    { return (auto(__x) += __y); }
  8857	
  8858	    friend constexpr _Iterator
  8859	    operator+(difference_type __x, const _Iterator& __y)
  8860	    requires random_access_range<_Base>
  8861	    { return auto(__y) += __x; }
  8862	
  8863	    friend constexpr _Iterator
  8864	    operator-(const _Iterator& __x, difference_type __y)
  8865	    requires random_access_range<_Base>
  8866	    { return auto(__x) -= __y; }
  8867	
  8868	    friend constexpr difference_type
  8869	    operator-(const _Iterator& __x, const _Iterator& __y)
  8870	    { return __x._M_pos - __y._M_pos; }
  8871	
  8872	    friend constexpr auto
  8873	    iter_move(const _Iterator& __i)
  8874	    noexcept(noexcept(ranges::iter_move(__i._M_current))
  8875		     && is_nothrow_move_constructible_v<range_rvalue_reference_t<_Base>>)
  8876	    {
  8877	      return tuple<difference_type, range_rvalue_reference_t<_Base>>
  8878		(__i._M_pos, ranges::iter_move(__i._M_current));
  8879	    }
  8880	  };
  8881	
  8882	  template<view _Vp>
  8883	  requires __detail::__range_with_movable_reference<_Vp>
  8884	  template<bool _Const>
  8885	  class enumerate_view<_Vp>::_Sentinel
  8886	  {
  8887	    using _Base = __maybe_const_t<_Const, _Vp>;
  8888	
  8889	    sentinel_t<_Base> _M_end = sentinel_t<_Base>();
  8890	
  8891	    constexpr explicit
  8892	    _Sentinel(sentinel_t<_Base> __end)
  8893	    : _M_end(std::move(__end))
  8894	    { }
  8895	
  8896	    friend enumerate_view;
  8897	
  8898	  public:
  8899	    _Sentinel() = default;
  8900	
  8901	    constexpr
  8902	    _Sentinel(_Sentinel<!_Const> __other)
  8903	    requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
  8904	    : _M_end(std::move(__other._M_end))
  8905	    { }
  8906	
  8907	    constexpr sentinel_t<_Base>
  8908	    base() const
  8909	    { return _M_end; }
  8910	
  8911	    template<bool _OtherConst>
  8912	    requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
  8913	    friend constexpr bool
  8914	    operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
  8915	    { return __x._M_current == __y._M_end; }
  8916	
  8917	    template<bool _OtherConst>
  8918	    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
  8919	    friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
  8920	    operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
  8921	    { return __x._M_current - __y._M_end; }
  8922	
  8923	    template<bool _OtherConst>
  8924	    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
  8925	    friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
  8926	    operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y)
  8927	    { return __x._M_end - __y._M_current; }
  8928	  };
  8929	
  8930	  namespace views
  8931	  {
  8932	    namespace __detail
  8933	    {
  8934	      template<typename _Tp>
  8935		concept __can_enumerate_view
  8936		  = requires { enumerate_view<all_t<_Tp>>(std::declval<_Tp>()); };
  8937	    }
  8938	
  8939	    struct _Enumerate : __adaptor::_RangeAdaptorClosure
  8940	    {
  8941	      template<viewable_range _Range>
  8942		requires __detail::__can_enumerate_view<_Range>
  8943		constexpr auto
  8944		operator() [[nodiscard]] (_Range&& __r) const
  8945		{ return enumerate_view<all_t<_Range>>(std::forward<_Range>(__r)); }
  8946	    };
  8947	
  8948	    inline constexpr _Enumerate enumerate;
  8949	  }
  8950	
  8951	#define __cpp_lib_ranges_as_const 202207L
  8952	
  8953	  template<view _Vp>
  8954	    requires input_range<_Vp>
  8955	  class as_const_view : public view_interface<as_const_view<_Vp>>
  8956	  {
  8957	    _Vp _M_base = _Vp();
  8958	
  8959	  public:
  8960	    as_const_view() requires default_initializable<_Vp> = default;
  8961	
  8962	    constexpr explicit
  8963	    as_const_view(_Vp __base)
  8964	    noexcept(is_nothrow_move_constructible_v<_Vp>)
  8965	    : _M_base(std::move(__base))
  8966	    { }
  8967	
  8968	    constexpr _Vp
  8969	    base() const &
  8970	    noexcept(is_nothrow_copy_constructible_v<_Vp>)
  8971	    requires copy_constructible<_Vp>
  8972	    { return _M_base; }
  8973	
  8974	    constexpr _Vp
  8975	    base() &&
  8976	    noexcept(is_nothrow_move_constructible_v<_Vp>)
  8977	    { return std::move(_M_base); }
  8978	
  8979	    constexpr auto
  8980	    begin() requires (!__detail::__simple_view<_Vp>)
  8981	    { return ranges::cbegin(_M_base); }
  8982	
  8983	    constexpr auto
  8984	    begin() const requires range<const _Vp>
  8985	    { return ranges::cbegin(_M_base); }
  8986	
  8987	    constexpr auto
  8988	    end() requires (!__detail::__simple_view<_Vp>)
  8989	    { return ranges::cend(_M_base); }
  8990	
  8991	    constexpr auto
  8992	    end() const requires range<const _Vp>
  8993	    { return ranges::cend(_M_base); }
  8994	
  8995	    constexpr auto
  8996	    size() requires sized_range<_Vp>
  8997	    { return ranges::size(_M_base); }
  8998	
  8999	    constexpr auto
  9000	    size() const requires sized_range<const _Vp>
  9001	    { return ranges::size(_M_base); }
  9002	  };
  9003	
  9004	  template<typename _Range>
  9005	    as_const_view(_Range&&) -> as_const_view<views::all_t<_Range>>;
  9006	
  9007	  template<typename _Tp>
  9008	    inline constexpr bool enable_borrowed_range<as_const_view<_Tp>>
  9009	      = enable_borrowed_range<_Tp>;
  9010	
  9011	  namespace views
  9012	  {
  9013	    namespace __detail
  9014	    {
  9015	      template<typename _Tp>
  9016		inline constexpr bool __is_ref_view = false;
  9017	
  9018	      template<typename _Range>
  9019		inline constexpr bool __is_ref_view<ref_view<_Range>> = true;
  9020	
  9021	      template<typename _Range>
  9022		concept __can_as_const_view = requires { as_const_view(std::declval<_Range>()); };
  9023	    }
  9024	
  9025	    struct _AsConst : __adaptor::_RangeAdaptorClosure
  9026	    {
  9027	      template<viewable_range _Range>
  9028	      constexpr auto
  9029	      operator()(_Range&& __r) const
  9030	      noexcept(noexcept(as_const_view(std::declval<_Range>())))
  9031	      requires __detail::__can_as_const_view<_Range>
  9032	      {
  9033		using _Tp = remove_cvref_t<_Range>;
  9034		using element_type = remove_reference_t<range_reference_t<_Range>>;
  9035		if constexpr (constant_range<views::all_t<_Range>>)
  9036		  return views::all(std::forward<_Range>(__r));
  9037		else if constexpr (__detail::__is_empty_view<_Tp>)
  9038		  return views::empty<const element_type>;
  9039		else if constexpr (std::__detail::__is_span<_Tp>)
  9040		  return span<const element_type, _Tp::extent>(std::forward<_Range>(__r));
  9041		else if constexpr (__detail::__is_ref_view<_Tp>
  9042				   && constant_range<const element_type>)
  9043		  return ref_view(static_cast<const element_type&>
  9044				  (std::forward<_Range>(__r).base()));
  9045		else if constexpr (is_lvalue_reference_v<_Range>
  9046				   && constant_range<const _Tp>
  9047				   && !view<_Tp>)
  9048		  return ref_view(static_cast<const _Tp&>(__r));
  9049		else
  9050		  return as_const_view(std::forward<_Range>(__r));
  9051	      }
  9052	    };
  9053	
  9054	    inline constexpr _AsConst as_const;
  9055	  }
  9056	#endif // C++23
  9057	} // namespace ranges
  9058	
  9059	  namespace views = ranges::views;
  9060	
  9061	_GLIBCXX_END_NAMESPACE_VERSION
  9062	} // namespace
  9063	#endif // library concepts
  9064	#endif // C++2a
  9065	#endif /* _GLIBCXX_RANGES */