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