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