Standard library header <ranges> (C++20)

// 大部分はフリースタンディング
#include <compare>
#include <initializer_list>
#include <iterator>
namespace std::ranges {
  inline namespace /* 未指定 */ {
    // 範囲アクセス
    inline constexpr /* 未指定 */ begin        = /* 未指定 */;
    inline constexpr /* 未指定 */ end          = /* 未指定 */;
    inline constexpr /* 未指定 */ cbegin       = /* 未指定 */;
    inline constexpr /* 未指定 */ cend         = /* 未指定 */;
    inline constexpr /* 未指定 */ rbegin       = /* 未指定 */;
    inline constexpr /* 未指定 */ rend         = /* 未指定 */;
    inline constexpr /* 未指定 */ crbegin      = /* 未指定 */;
    inline constexpr /* 未指定 */ crend        = /* 未指定 */;
    inline constexpr /* 未指定 */ size         = /* 未指定 */;
    inline constexpr /* 未指定 */ reserve_hint = /* 未指定 */;
    inline constexpr /* 未指定 */ ssize        = /* 未指定 */;
    inline constexpr /* 未指定 */ empty        = /* 未指定 */;
    inline constexpr /* 未指定 */ data         = /* 未指定 */;
    inline constexpr /* 未指定 */ cdata        = /* 未指定 */;
  }
  // 範囲
  template<class T>
  concept range = /* 説明を参照 */;
  template<class T>
  constexpr bool enable_borrowed_range = false;
  template<class T>
  concept borrowed_range = /* 説明を参照 */;
  template<class T>
  using iterator_t = decltype(ranges::begin(declval<T&>()));
  template<range R>
  using sentinel_t = decltype(ranges::end(declval<R&>()));
  template<range R>
  using const_iterator_t = decltype(ranges::cbegin(declval<R&>()));
  template<range R>
  using const_sentinel_t = decltype(ranges::cend(declval<R&>()));
  template<range R>
  using range_difference_t = iter_difference_t<iterator_t<R>>;
  template<sized_range R>
  using range_size_t = decltype(ranges::size(declval<R&>()));
  template<range R>
  using range_value_t = iter_value_t<iterator_t<R>>;
  template<range R>
  using range_reference_t = iter_reference_t<iterator_t<R>>;
  template<range R>
  using range_const_reference_t = iter_const_reference_t<iterator_t<R>>;
  template<range R>
  using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;
  template<range R>
  using range_common_reference_t = iter_common_reference_t<iterator_t<R>>;
  // サイズ指定された範囲
  template<class>
  constexpr bool disable_sized_range = false;
  template<class T>
  concept approximately_sized_range = /* 説明を参照 */;
  template<class T>
  concept sized_range = /* 説明を参照 */;
  // ビュー
  template<class T>
  constexpr bool enable_view = /* 説明を参照 */;
  struct view_base
  {};
  template<class T>
  concept view = /* 説明を参照 */;
  // その他の範囲の改良
  template<class R, class T>
  concept output_range = /* 説明を参照 */;
  template<class T>
  concept input_range = /* 説明を参照 */;
  template<class T>
  concept forward_range = /* 説明を参照 */;
  template<class T>
  concept bidirectional_range = /* 説明を参照 */;
  template<class T>
  concept random_access_range = /* 説明を参照 */;
  template<class T>
  concept contiguous_range = /* 詳細は説明を参照 */;
  template<class T>
  concept common_range = /* 詳細は説明を参照 */;
  template<class T>
  concept viewable_range = /* 詳細は説明を参照 */;
  template<class T>
  concept constant_range = /* 説明を参照 */;
  // クラステンプレート view_interface
  template<class D>
    requires is_class_v<D> && same_as<D, remove_cv_t<D>>
  class view_interface;
  // サブレンジ
  enum class subrange_kind : bool
  {
    unsized,
    sized
  };
  template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K =
             /* 詳細は説明を参照 */>
    requires(K == subrange_kind::サイズ指定済み || !sized_sentinel_for<S, I>)
  class subrange;
  template<class I, class S, subrange_kind K>
  constexpr bool enable_borrowed_range<subrange<I, S, K>> = true;
  template<size_t N, class I, class S, subrange_kind K>
    requires((N == 0 && copyable<I>) || N == 1)
  constexpr auto get(const subrange<I, S, K>& r);
  template<size_t N, class I, class S, subrange_kind K>
    requires(N < 2)
  constexpr auto get(subrange<I, S, K>&& r);
}
namespace std {
  using ranges::get;
}
namespace std::ranges {
  // ダングリングイテレータの処理
  struct dangling;
  // クラステンプレート elements_of
  template<range R, class Allocator = allocator<byte>>
  struct elements_of; // ホストされた
  template<range R>
  using borrowed_iterator_t = /* 詳細は説明を参照 */;
  template<range R>
  using borrowed_subrange_t = /* 説明を参照 */;
  // 範囲変換
  template<class C, input_range R, class... Args>
    requires(!view<C>)
  constexpr C to(R&& r, Args&&... args);
  template<template<class...> class C, input_range R, class... Args>
  constexpr auto to(R&& r, Args&&... args);
  template<class C, class... Args>
    requires(!view<C>)
  constexpr auto to(Args&&... args);
  template<template<class...> class C, class... Args>
  constexpr auto to(Args&&... args);
  // 空のビュー
  template<class T>
    requires is_object_v<T>
  class empty_view;
  template<class T>
  constexpr bool enable_borrowed_range<empty_view<T>> = true;
  namespace views {
    template<class T>
    constexpr empty_view<T> empty{};
  }
  // 単一ビュー
  template<move_constructible T>
    requires is_object_v<T>
  class single_view;
  namespace views {
    inline constexpr /* 未指定 */ single = /* 未指定 */;
  }
  template<bool Const, class T>
  using /*maybe-const*/ = conditional_t<Const, const T, T>; // 説明専用
  // iota ビュー
  template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
    requires /*weakly-equality-comparable-with*/<W, Bound> && copyable<W>
  class iota_view;
  template<class W, class Bound>
  constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true;
  namespace views {
    inline constexpr /* 未指定 */ iota = /* 未指定 */;
  }
  // 繰り返し表示
  template<move_constructible T, semiregular Bound = unreachable_sentinel_t>
    requires /* 詳細は説明を参照 */
  class repeat_view;
  namespace views {
    inline constexpr /* 未指定 */ repeat = /* 未指定 */;
  }
  // istream ビュー
  template<movable Val, class CharT, class Traits = char_traits<CharT>>
    requires                /* 説明を参照 */
  class basic_istream_view; // ホストされた
  template<class Val>
  using istream_view = basic_istream_view<Val, char>; // ホスト環境
  template<class Val>
  using wistream_view = basic_istream_view<Val, wchar_t>; // ホスト環境
  namespace views {
    template<class T>
    constexpr /* 未指定 */ istream = /* 未指定 */; // ホスト環境
  }
  // レンジアダプタオブジェクト
  template<class D>
    requires is_class_v<D> && same_as<D, remove_cv_t<D>>
  class range_adaptor_closure
  {};
  // 全体表示
  namespace views {
    inline constexpr /* 未指定 */ all = /* 未指定 */;
    template<viewable_range R>
    using all_t = decltype(all(declval<R>()));
  }
  // ref view
  template<range R>
    requires is_object_v<R>
  class ref_view;
  template<class T>
  constexpr bool enable_borrowed_range<ref_view<T>> = true;
  // owning view
  template<range R>
    requires /* 説明を参照 */
  class owning_view;
  template<class T>
  constexpr bool enable_borrowed_range<owning_view<T>> = enable_borrowed_range<T>;
  // 右辺値ビューとして
  template<view V>
    requires input_range<V>
  class as_rvalue_view;
  template<class T>
  constexpr bool enable_borrowed_range<as_rvalue_view<T>> = enable_borrowed_range<T>;
  namespace views {
    inline constexpr /* 未指定 */ as_rvalue = /* 未指定 */;
  }
  // フィルタービュー
  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
    requires view<V> && is_object_v<Pred>
  class filter_view;
  namespace views {
    inline constexpr /* 未指定 */ filter = /* 未指定 */;
  }
  // 変換ビュー
  template<input_range V, move_constructible F>
    requires view<V> && is_object_v<F> && regular_invocable<F&, range_reference_t<V>> &&
             /*参照可能*/<invoke_result_t<F&, range_reference_t<V>>>
  class transform_view;
  namespace views {
    inline constexpr /* 未指定 */ transform = /* 未指定 */;
  }
  // ビューを取得
  template<view>
  class take_view;
  template<class T>
  constexpr bool enable_borrowed_range<take_view<T>> = enable_borrowed_range<T>;
  namespace views {
    inline constexpr /* 未指定 */ take = /* 未指定 */;
  }
  // take while view
  template<view V, class Pred>
    requires input_range<V> && is_object_v<Pred> &&
             indirect_unary_predicate<const Pred, iterator_t<V>>
  class take_while_view;
  namespace views {
    inline constexpr /* 未指定 */ take_while = /* 未指定 */;
  }
  // ビューの削除
  template<view V>
  class drop_view;
  template<class T>
  constexpr bool enable_borrowed_range<drop_view<T>> = enable_borrowed_range<T>;
  namespace views {
    inline constexpr /* 未指定 */ drop = /* 未指定 */;
  }
  // drop while view
  template<view V, class Pred>
    requires input_range<V> && is_object_v<Pred> &&
             indirect_unary_predicate<const Pred, iterator_t<V>>
  class drop_while_view;
  template<class T, class Pred>
  constexpr bool enable_borrowed_range<drop_while_view<T, Pred>> =
    enable_borrowed_range<T>;
  namespace views {
    inline constexpr /* 未指定 */ drop_while = /* 未指定 */;
  }
  // join ビュー
  template<input_range V>
    requires view<V> && input_range<range_reference_t<V>>
  class join_view;
  namespace views {
    inline constexpr /* 未指定 */ join = /* 未指定 */;
  }
  // ビューでの結合
  template<input_range V, forward_range Pattern>
    requires /* 説明を参照 */
  class join_with_view;
  namespace views {
    inline constexpr /* 未指定 */ join_with = /* 未指定 */;
  }
  // 遅延分割ビュー
  template<class R>
  concept /*tiny-range*/ = /* 説明を参照 */; // 説明専用
  template<input_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
             indirectly_comparable<iterator_t<V>,
                                   iterator_t<Pattern>,
                                   ranges::equal_to> &&
             (forward_range<V> || /*tiny-range*/<Pattern>)
  class lazy_split_view;
  // 分割ビュー
  template<forward_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>
  class split_view;
  namespace views {
    inline constexpr /* 未指定 */ lazy_split = /* 未指定 */;
    inline constexpr /* 未指定 */ split      = /* 未指定 */;
  }
  // 連結ビュー
  template<input_range... ビュー>
    requires /* 詳細は説明を参照 */
  class concat_view;
  namespace views {
    inline constexpr /* 未指定 */ concat = /* 未指定 */;
  }
  // カウント付きビュー
  namespace views {
    inline constexpr /* 未指定 */ counted = /* 未指定 */;
  }
  // 共通ビュー
  template<view V>
    requires(!common_range<V> && copyable<iterator_t<V>>)
  class common_view;
  template<class T>
  constexpr bool enable_borrowed_range<common_view<T>> = enable_borrowed_range<T>;
  namespace views {
    inline constexpr /* 未指定 */ common = /* 未指定 */;
  }
  // リバースビュー
  template<view V>
    requires bidirectional_range<V>
  class reverse_view;
  template<class T>
  constexpr bool enable_borrowed_range<reverse_view<T>> = enable_borrowed_range<T>;
  namespace views {
    inline constexpr /* 未指定 */ reverse = /* 未指定 */;
  }
  // const ビューとして
  template<input_range R>
  constexpr auto& /*possibly-const-range*/(R& r) noexcept
  { // 説明専用
    if constexpr (input_range<const R>) {
      return const_cast<const R&>(r);
    } else {
      return r;
    }
  }
  template<view V>
    requires input_range<V>
  class as_const_view;
  template<class T>
  constexpr bool enable_borrowed_range<as_const_view<T>> = enable_borrowed_range<T>;
  namespace views {
    inline constexpr /* 未指定 */ as_const = /* 未指定 */;
  }
  // 要素ビュー
  template<input_range V, size_t N>
    requires /* 説明を参照 */
  class elements_view;
  template<class T, size_t N>
  constexpr bool enable_borrowed_range<elements_view<T, N>> = enable_borrowed_range<T>;
  template<class R>
  using keys_view = elements_view<R, 0>;
  template<class R>
  using values_view = elements_view<R, 1>;
  namespace views {
    template<size_t N>
    constexpr /* 未指定 */ elements = /* 未指定 */;
    inline constexpr auto keys           = elements<0>;
    inline constexpr auto values         = elements<1>;
  }
  // 列挙ビュー
  template<view V>
    requires /* 詳細は説明を参照 */
  class enumerate_view;
  template<class View>
  constexpr bool enable_borrowed_range<enumerate_view<View>> =
    enable_borrowed_range<View>;
  namespace views {
    inline constexpr /* 未指定 */ enumerate = /* 未指定 */;
  }
  // zip ビュー
  template<input_range... ビュー>
    requires(view<Views> && ...) && (sizeof...(Views) > 0)
  class zip_view;
  template<class... ビュー>
  constexpr bool enable_borrowed_range<zip_view<Views...>> =
    (enable_borrowed_range<Views> && ...);
  namespace views {
    inline constexpr /* 未指定 */ zip = /* 未指定 */;
  }
  // zip transform ビュー
  template<move_constructible F, input_range... ビュー>
    requires(view<Views> && ...) && (sizeof...(Views) > 0) && is_object_v<F> &&
            regular_invocable<F&, range_reference_t<Views>...> &&
            /*参照可能*/<invoke_result_t<F&, range_reference_t<Views>...>>
  class zip_transform_view;
  namespace views {
    inline constexpr /* 未指定 */ zip_transform = /* 未指定 */;
  }
  // 隣接ビュー
  template<forward_range V, size_t N>
    requires view<V> && (N > 0)
  class adjacent_view;
  template<class V, size_t N>
  constexpr bool enable_borrowed_range<adjacent_view<V, N>> = enable_borrowed_range<V>;
  namespace views {
    template<size_t N>
    constexpr /* 未指定 */ adjacent = /* 未指定 */;
    inline constexpr auto pairwise       = adjacent<2>;
  }
  // 隣接変換ビュー
  template<forward_range V, move_constructible F, size_t N>
    requires /* 説明を参照 */
  class adjacent_transform_view;
  namespace views {
    template<size_t N>
    constexpr /* 未指定 */ adjacent_transform = /* 未指定 */;
    inline constexpr auto pairwise_transform       = adjacent_transform<2>;
  }
  // チャンクビュー
  template<view V>
    requires input_range<V>
  class chunk_view;
  template<view V>
    requires forward_range<V>
  class chunk_view<V>;
  template<class V>
  constexpr bool enable_borrowed_range<chunk_view<V>> =
    forward_range<V> && enable_borrowed_range<V>;
  namespace views {
    inline constexpr /* 未指定 */ chunk = /* 未指定 */;
  }
  // スライドビュー
  template<forward_range V>
    requires view<V>
  class slide_view;
  template<class V>
  constexpr bool enable_borrowed_range<slide_view<V>> = enable_borrowed_range<V>;
  namespace views {
    inline constexpr /* 未指定 */ slide = /* 未指定 */;
  }
  // ビューによるチャンク
  template<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred>
    requires view<V> && is_object_v<Pred>
  class chunk_by_view;
  namespace views {
    inline constexpr /* 未指定 */ chunk_by = /* 未指定 */;
  }
  // ストライドビュー
  template<input_range V>
    requires view<V>
  class stride_view;
  template<class V>
  constexpr bool enable_borrowed_range<stride_view<V>> = enable_borrowed_range<V>;
  namespace views {
    inline constexpr /* 未指定 */ stride = /* 未指定 */;
  }
  // 直積ビュー
  template<input_range First, forward_range... Vs>
    requires(view<First> && ... && view<Vs>)
  class cartesian_product_view;
  namespace views {
    inline constexpr /* 未指定 */ cartesian_product = /* 未指定 */;
  }
  // 最新のビューをキャッシュ
  template<input_range V>
    requires view<V>
  class cache_latest_view;
  namespace views {
    inline constexpr /* 未指定 */ cache_latest = /* 未指定 */;
  }
  // 入力ビューへ
  template<input_range V>
    requires view<V>
  class to_input_view;
  template<class V>
  constexpr bool enable_borrowed_range<to_input_view<V>> = enable_borrowed_range<V>;
  namespace views {
    inline constexpr /* 未指定 */ to_input = /* 未指定 */;
  }
}
namespace std {
  namespace views = ranges::ビュー;
  template<class T>
  struct tuple_size;
  template<size_t I, class T>
  struct tuple_element;
  template<class I, class S, ranges::subrange_kind K>
  struct tuple_size<ranges::subrange<I, S, K>> : integral_constant<size_t, 2>
  {};
  template<class I, class S, ranges::subrange_kind K>
  struct tuple_element<0, ranges::subrange
（注：指定された条件により、HTMLタグ・属性は保持され、C++固有用語（ranges::subrange）は翻訳対象外のため、元のテキストをそのまま保持しています）<I, S, K>>
  {
    using type = I;
  };
  template<class I, class S, ranges::subrange_kind K>
  struct tuple_element<1, ranges::subrange<I, S, K>>
  {
    using type = S;
  };
  template<class I, class S, ranges::subrange_kind K>
  struct tuple_element<0, const ranges::subrange<I, S, K>>
  {
    using type = I;
  };
  template<class I, class S, ranges::subrange_kind K>
  struct tuple_element<1, const ranges::subrange<I, S, K>>
  {
    using type = S;
  };
  struct from_range_t
  {
    explicit from_range_t() = default;
  };
  inline constexpr from_range_t from_range{};
}

namespace std::ranges {
  template<class T>
  concept range = requires(T& t) {
    ranges::begin(t); // 場合によって等価性を保持する（説明を参照）
    ranges::end(t);
  };
}

namespace std::ranges {
  template<class T>
  concept borrowed_range =
    range<T> && (is_lvalue_reference_v<T> || enable_borrowed_range<remove_cvref_t<T>>);
}

namespace std::ranges {
  template<class T>
  concept approximately_sized_range = range<T> && requires(T& t) {
    ranges::reserve_hint(t);
  };
}

namespace std::ranges {
  template<class T>
  concept sized_range = approximately_sized_range<T> && requires(T& t) {
    ranges::size(t);
  };
}

namespace std::ranges {
  template<class T>
  constexpr bool /*is-derived-from-view-interface*/ =
    /* 説明を参照 */; // 説明専用
  template<class T>
  constexpr bool enable_view =
    derived_from<T, view_base> || /*is-derived-from-view-interface*/<T>;
  template<class T>
  concept view = range<T> && movable<T> && enable_view<T>;
}

namespace std::ranges {
  template<class R, class T>
  concept output_range = range<R> && output_iterator<iterator_t<R>, T>;
}

namespace std::ranges {
  template<class T>
  concept input_range = range<T> && input_iterator<iterator_t<T>>;
}

namespace std::ranges {
  template<class T>
  concept forward_range = input_range<T> && forward_iterator<iterator_t<T>>;
}

namespace std::ranges {
  template<class T>
  concept bidirectional_range = forward_range<T> && bidirectional_iterator<iterator_t<T>>;
}

namespace std::ranges {
  template<class T>
  concept random_access_range =
    bidirectional_range<T> && random_access_iterator<iterator_t<T>>;
}

namespace std::ranges {
  template<class T>
  concept contiguous_range =
    random_access_range<T> && contiguous_iterator<iterator_t<T>> && requires(T& t) {
      {
        ranges::data(t)
      } -> same_as<add_pointer_t<range_reference_t<T>>>;
    };
}

namespace std::ranges {
  template<class T>
  concept common_range = range<T> && same_as<iterator_t<T>, sentinel_t<T>>;
}

namespace std::ranges {
  template<class T>
  concept viewable_range =
    range<T> && ((view<remove_cvref_t<T>> && constructible_from<remove_cvref_t<T>, T>) ||
                 (!view<remove_cvref_t<T>> &&
                  (is_lvalue_reference_v<T> ||
                   (movable<remove_reference_t<T>> && !/*is-initializer-list*/<T>))));
}

namespace std::ranges {
  template<class T>
  concept constant_range = input_range<T> && /*constant-iterator*/<iterator_t<T>>;
}

namespace std::ranges { // 未規定、名前探索のみのため
  template<class R>
  concept /*simple-view*/ = // 説明専用
    view<R> && range<const R> && same_as<iterator_t<R>, iterator_t<const R>> &&
    same_as<sentinel_t<R>, sentinel_t<const R>>;
  template<class I>
  concept /*has-arrow*/ = // 説明専用
    input_iterator<I> && (is_pointer_v<I> || requires(const I i) { i.operator->(); });
  template<class T, class U>
  concept /*different-from*/ = // 説明専用
    !same_as<remove_cvref_t<T>, remove_cvref_t<U>>;
  template<class R>
  concept /*range-with-movable-references*/ = // 説明専用
    input_range<R> && move_constructible<range_reference_t<R>> &&
    move_constructible<range_rvalue_reference_t<R>>;
  template<class R>
  constexpr bool /*is-initializer-list*/ = /* 説明を参照 */; // 説明専用
  template<class T>
  constexpr auto
  /*as-const-pointer*/(const T* p) noexcept
  {
    return p;
  } // 説明専用
}

namespace std::ranges {
  template<class D>
    requires is_class_v<D> && same_as<D, remove_cv_t<D>>
  class view_interface
  {
  private:
    constexpr D& /*派生*/() noexcept
    { // 説明専用
      return static_cast<D&>(*this);
    }
    constexpr const D& /*派生*/() const noexcept
    { // 説明専用
      return static_cast<const D&>(*this);
    }
  public:
    constexpr bool empty()
      requires sized_range<D> || forward_range<D>
    {
      if constexpr (sized_range<D>)
        return ranges::size(/*派生*/()) == 0;
      else
        return ranges::begin(/*派生*/()) == ranges::end(/*派生*/());
    }
    constexpr bool empty() const
      requires sized_range<const D> || forward_range<const D>
    {
      if constexpr (sized_range<const D>)
        return ranges::size(/*派生*/()) == 0;
      else
        return ranges::begin(/*派生*/()) == ranges::end(/*派生*/());
    }
    constexpr auto cbegin()
      requires input_range<D>
    {
      return ranges::cbegin(/*派生*/());
    }
    constexpr auto cbegin() const
      requires input_range<const D>
    {
      return ranges::cbegin(/*派生*/());
    }
    constexpr auto cend()
      requires input_range<D>
    {
      return ranges::cend(/*派生*/());
    }
    constexpr auto cend() const
      requires input_range<const D>
    {
      return ranges::cend(/*派生*/());
    }
    constexpr explicit operator bool()
      requires requires { ranges::empty(/*派生*/()); }
    {
      return !ranges::empty(/*派生*/());
    }
    constexpr explicit operator bool() const
      requires requires { ranges::empty(/*派生*/()); }
    {
      return !ranges::empty(/*派生*/());
    }
    constexpr auto data()
      requires contiguous_iterator<iterator_t<D>>
    {
      return to_address(ranges::begin(/*派生*/()));
    }
    constexpr auto data() const
      requires range<const D> && contiguous_iterator<iterator_t<const D>>
    {
      return to_address(ranges::begin(/*派生*/()));
    }
    constexpr auto size()
      requires forward_range<D> && sized_sentinel_for<sentinel_t<D>, iterator_t<D>>
    {
      return /*to-unsigned-like*/(ranges::end(/*派生*/()) -
                                  ranges::begin(/*派生*/()));
    }
    constexpr auto size() const
      requires forward_range<const D> &&
               sized_sentinel_for<sentinel_t<const D>, iterator_t<const D>>
    {
      return /*to-unsigned-like*/(ranges::end(/*派生*/()) -
                                  ranges::begin(/*派生*/()));
    }
    constexpr decltype(auto) front()
      requires forward_range<D>;
    constexpr decltype(auto) front() const
      requires forward_range<const D>;
    constexpr decltype(auto) back()
      requires bidirectional_range<D> && common_range<D>;
    constexpr decltype(auto) back() const
      requires bidirectional_range<const D> && common_range<const D>;
    template<random_access_range R = D>
    constexpr decltype(auto) operator[](range_difference_t<R> n)
    {
      return ranges::begin(/*派生*/())[n];
    }
    template<random_access_range R = const D>
    constexpr decltype(auto) operator[](range_difference_t<R> n) const
    {
      return ranges::begin(/*派生*/())[n]
（注：元のテキストは閉じ括弧のみのため、日本語でも同じ記号を保持します）;
    }
  };
}

namespace std::ranges {
  template<class From, class To>
  concept /*非修飾ポインタ変換を使用*/ = // 説明専用
    is_pointer_v<From> && is_pointer_v<To> &&
    !convertible_to<remove_pointer_t<From> (*)[], remove_pointer_t<To> (*)[]>;
  template<class From, class To>
  concept /*非スライシング変換可能*/ = // 説明専用
    convertible_to<From, To> &&
    !/*非修飾ポインタ変換を使用*/<decay_t<From>, decay_t<To>>;
  template<class T, class U, class V>
  concept /*pair-like-convertible-from*/ = // 説明専用
    !range<T> && !is_reference_v<T> && /*pair-like*/<T> && constructible_from<T, U, V> &&
    /*非スライシング変換可能*/<U, tuple_element_t<0, T>> &&
    convertible_to<V, tuple_element_t<1, T>>;
  template<input_or_output_iterator I,
           sentinel_for<I> S = I,
           subrange_kind K =
             sized_sentinel_for<S, I> ? subrange_kind::sized : subrange_kind::unsized>
    requires(K == subrange_kind::sized || !sized_sentinel_for<S, I>)
  class subrange : public view_interface<subrange<I, S, K>>
  {
  private:
    static constexpr bool /*StoreSize*/ = // 説明専用
      K == subrange_kind::sized && !sized_sentinel_for<S, I>;
    I /*開始_*/ = I(); // 説明専用
    S /*end_*/   = S(); // 説明専用
    /*make-unsigned-like-t*/<iter_difference_t<I>> /*size_*/ =
      0; // 説明専用 表示のみ
         // StoreSizeがtrueの場合
  public:
    subrange()
      requires default_initializable<I>
    = default;
    constexpr subrange(/*非スライシング変換可能*/<I> auto i, S s)
      requires(!/*StoreSize*/);
    constexpr subrange(/*非スライシング変換可能*/<I> auto i,
                       S s,
                       /*make-unsigned-like-t*/<iter_difference_t<I>> n)
      requires(K == subrange_kind::sized);
    template</*異なる*/<subrange> R>
      requires borrowed_range<R> && /*非スライシング変換可能*/<iterator_t<R>, I> &&
               convertible_to<sentinel_t<R>, S>
               constexpr subrange(R&& r)
                 requires(!/*StoreSize*/ || sized_range<R>);
    template<borrowed_range R>
      requires /*非スライシング変換可能*/<iterator_t<R>, I> &&
               convertible_to<sentinel_t<R>, S>
               constexpr subrange(R&& r, /*make-unsigned-like-t*/<iter_difference_t<I>> n)
                 requires(K == subrange_kind::sized)
      : subrange{ ranges::begin(r), ranges::end(r), n }
    {
    }
    template</*異なる*/<subrange> PairLike>
      requires /*pair-like-convertible-from*/<PairLike, const I&, const S&>
    constexpr operator PairLike() const;
    constexpr I begin() const
      requires copyable<I>;
    constexpr I begin()
      requires(!copyable<I>);
    constexpr S end() const;
    constexpr bool empty() const;
    constexpr /*make-unsigned-like-t*/<iter_difference_t<I>> size() const
      requires(K == subrange_kind::sized);
    constexpr subrange next(iter_difference_t<I> n = 1) const&
      requires forward_iterator<I>;
    constexpr subrange next(iter_difference_t<I> n = 1) &&;
    constexpr subrange prev(iter_difference_t<I> n = 1) const
      requires bidirectional_iterator<I>;
    constexpr subrange& advance(iter_difference_t<I> n);
  };
  template<input_or_output_iterator I, sentinel_for<I> S>
  subrange(I, S) -> subrange<I, S>;
  template<input_or_output_iterator I, sentinel_for<I> S>
  subrange(I, S, /*make-unsigned-like-t*/<iter_difference_t<I>>)
    -> subrange<I, S, subrange_kind::sized>;
  template<borrowed_range R>
  subrange(R&&)
    -> subrange<iterator_t<R>,
                sentinel_t<R>,
                (sized_range<R> || sized_sentinel_for<sentinel_t<R>, iterator_t<R>>)
                  ? subrange_kind::sized
                  : subrange_kind::unsized>;
  template<borrowed_range R>
  subrange(R&&, /*make-unsigned-like-t*/<range_difference_t<R>>)
    -> subrange<iterator_t<R>, sentinel_t<R>, subrange_kind::sized>;
}

namespace std::ranges {
  struct dangling
  {
    constexpr dangling() noexcept = default;
    constexpr dangling(auto&&...) noexcept {}
  };
}

namespace std::ranges {
  template<range R, class Allocator = allocator<byte>>
  struct elements_of
  {
    [[no_unique_address]] R range;
    [[no_unique_address]] Allocator allocator = Allocator();
  };
  template<class R, class Allocator = allocator<byte>>
  elements_of(R&&, Allocator = Allocator()) -> elements_of<R&&, Allocator>;
}

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

namespace std::ranges {
  template<move_constructible T>
    requires is_object_v<T>
  class single_view : public view_interface<single_view<T>>
  {
  private:
    /*movable-box*/<T> /*value_*/; // 説明専用
  public:
    single_view()
      requires default_initializable<T>
    = default;
    constexpr explicit single_view(const T& t)
      requires copy_constructible<T>;
    constexpr explicit single_view(T&& t);
    template<class... Args>
      requires constructible_from<T, Args...>
    constexpr explicit single_view(in_place_t, Args&&... args);
    constexpr T* begin() noexcept;
    constexpr const T* begin() const noexcept;
    constexpr T* end() noexcept;
    constexpr const T* end() const noexcept;
    static constexpr bool empty() noexcept;
    static constexpr size_t size() noexcept;
    constexpr T* data() noexcept;
    constexpr const T* data() const noexcept;
  };
  template<class T>
  single_view(T) -> single_view<T>;
}

namespace std::ranges {
  template<class I>
  concept /*decrementable*/ = /* 説明を参照 */; // 説明専用
  template<class I>
  concept /*advanceable*/ = /* 説明を参照 */; // 説明専用
  template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
    requires /*weakly-equality-comparable-with*/<W, Bound> && copyable<W>
  class iota_view : public view_interface<iota_view<W, Bound>>
  {
  private:
    // クラス iota_view::iterator
    struct /*iterator*/; // 説明専用
    // クラス iota_view::sentinel
    struct /*sentinel*/; // 説明専用
    W /*value_*/     = W();     // 説明専用
    Bound /*bound_*/ = Bound(); // 説明専用
  public:
    iota_view()
      requires default_initializable<W>
    = default;
    constexpr explicit iota_view(W value);
    constexpr explicit iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);
    constexpr explicit iota_view(/*iterator*/ first, /* 説明を参照 */ last);
    constexpr /*iterator*/ begin() const;
    constexpr auto end() const;
    constexpr /*iterator*/ end() const
      requires same_as<W, Bound>;
    constexpr bool empty() const;
    constexpr auto size() const
      requires /* 説明を参照 */;
  };
  template<class W, class Bound>
    requires(!/*is-integer-like*/<W> || !/*is-integer-like*/<Bound> ||
             (/*is-signed-integer-like*/<W> == /*is-signed-integer-like*/<Bound>))
  iota_view(W, Bound) -> iota_view<W, Bound>;
}

namespace std::ranges {
  template<weakly_incrementable W, semiregular Bound>
    requires /*weakly-equality-comparable-with*/<W, Bound> && copyable<W>
  struct iota_view<W, Bound>::/*iterator*/
  {
  private:
    W /*value_*/ = W(); // 説明専用
  public:
    using iterator_concept = /* 説明を参照 */;
    using iterator_category =
      input_iterator_tag; // Wがincrementableをモデルし、かつ
                          // IOTA-DIFF-T(W)が整数型である場合にのみ存在
    using value_type      = W;
    using difference_type = /*IOTA-DIFF-T*/(W);
    /*iterator*/()
      requires default_initializable<W>
    = default;
    constexpr explicit /*iterator*/(W value);
    constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v<W>);
    constexpr /*iterator*/& operator++();
    constexpr void operator++(int);
    constexpr /*iterator*/ operator++(int)
      requires incrementable<W>;
    constexpr /*iterator*/& operator--()
      requires /*decrementable*/<W>;
    constexpr /*iterator*/ operator--(int)
      requires /*decrementable*/<W>;
    constexpr /*iterator*/& operator+=(difference_type n)
      requires /*advanceable*/<W>;
    constexpr /*iterator*/& operator-=(difference_type n)
      requires /*advanceable*/<W>;
    constexpr W operator[](difference_type n) const
      requires /*advanceable*/<W>;
    friend constexpr bool operator==(const /*iterator*/& x, const /*iterator*/& y)
      requires equality_comparable<W>;
    friend constexpr bool operator<(const /*iterator*/& x, const /*iterator*/& y)
      requires totally_ordered<W>;
    friend constexpr bool operator>(const /*iterator*/& x, const /*iterator*/& y)
      requires totally_ordered<W>;
    friend constexpr bool operator<=(const /*iterator*/& x, const /*iterator*/& y)
      requires totally_ordered<W>;
    friend constexpr bool operator>=(const /*iterator*/& x, const /*iterator*/& y)
      requires totally_ordered<W>;
    friend constexpr auto operator<=>(const /*iterator*/& x, const /*iterator*/& y)
      requires totally_ordered<W> && three_way_comparable<W>;
    friend constexpr /*iterator*/ operator+(/*iterator*/ i, difference_type n)
      requires /*advanceable*/<W>;
    friend constexpr /*iterator*/ operator+(difference_type n, /*iterator*/ i)
      requires /*advanceable*/<W>;
    friend constexpr /*iterator*/ operator-(/*iterator*/ i, difference_type n)
      requires /*advanceable*/<W>;
    friend constexpr difference_type operator-(const /*iterator*/& x,
                                               const /*iterator*/& y)
      requires /*advanceable*/<W>;
  };
}

namespace std::ranges {
  template<weakly_incrementable W, semiregular Bound>
    requires /*weakly-equality-comparable-with*/<W, Bound> && copyable<W>
  struct iota_view<W, Bound>::/*sentinel*/
  {
  private:
    Bound /*bound_*/ = Bound(); // 説明専用
  public:
    /*sentinel*/() = default;
    constexpr explicit /*sentinel*/(Bound bound);
    friend constexpr bool operator==(const /*iterator*/& x, const /*sentinel*/& y);
    friend constexpr iter_difference_t<W> operator-(const /*iterator*/& x,
                                                    const /*sentinel*/& y)
      requires sized_sentinel_for<Bound, W>;
    friend constexpr iter_difference_t<W> operator-(const /*sentinel*/& x,
                                                    const /*iterator*/& y)
      requires sized_sentinel_for<Bound, W>;
  };
}

namespace std::ranges {
  template<class T>
  concept /*integer-like-with-usable-difference-type*/ = // 説明専用
    /*is-signed-integer-like*/<T> || (/*is-integer-like*/<T> && weakly_incrementable<T>);
  template<move_constructible T, semiregular Bound = unreachable_sentinel_t>
    requires(is_object_v<T> && same_as<T, remove_cv_t<T>> &&
             (/*integer-like-with-usable-difference-type*/<Bound> ||
              same_as<Bound, unreachable_sentinel_t>))
  class repeat_view : public view_interface<repeat_view<T, Bound>>
  {
  private:
    // repeat_view::iteratorクラス
    struct /*iterator*/; // 説明専用
    /*movable-box*/<T> /*value_*/; // 説明専用
    Bound /*bound_*/ = Bound();    // 説明専用
  public:
    repeat_view()
      requires default_initializable<T>
    = default;
    constexpr explicit repeat_view(const T& value, Bound bound = Bound())
      requires copy_constructible<T>;
    constexpr explicit repeat_view(T&& value, Bound bound = Bound());
    template<class... TArgs, class... BoundArgs>
      requires constructible_from<T, TArgs...> && constructible_from<Bound, BoundArgs...>
    constexpr explicit repeat_view(piecewise_construct_t,
                                   tuple<TArgs...> value_args,
                                   tuple<BoundArgs...> bound_args = tuple<>{});
    constexpr /*iterator*/ begin() const;
    constexpr /*iterator*/ end() const
      requires(!same_as<Bound, unreachable_sentinel_t>);
    constexpr unreachable_sentinel_t end() const noexcept;
    constexpr auto size() const
      requires(!same_as<Bound, unreachable_sentinel_t>);
  };
  template<class T, class Bound = unreachable_sentinel_t>
  repeat_view(T, Bound = Bound()) -> repeat_view<T, Bound>;
}

namespace std::ranges {
  template<move_constructible T, semiregular Bound>
    requires(is_object_v<T> && same_as<T, remove_cv_t<T>> &&
             (/*integer-like-with-usable-difference-type*/<Bound> ||
              same_as<Bound, unreachable_sentinel_t>))
  class repeat_view<T, Bound>::/*iterator*/
  {
  private:
    using /*index-type*/ = // 説明専用
      conditional_t<same_as<Bound, unreachable_sentinel_t>, ptrdiff_t, Bound>;
    const T* /*value_*/         = nullptr;          // 説明専用
    /*index-type*/ /*current_*/ = /*index-type*/(); // 説明専用
    constexpr explicit /*iterator*/(
      const T* value,
      /*index-type*/ b = /*index-type*/()); // 説明専用
  public:
    using iterator_concept  = random_access_iterator_tag;
    using iterator_category = random_access_iterator_tag;
    using value_type        = T;
    using difference_type   = /* 説明を参照 */;
    /*iterator*/()          = default;
    constexpr const T& operator*() const noexcept;
    constexpr /*iterator*/& operator++();
    constexpr /*iterator*/ operator++(int);
    constexpr /*iterator*/& operator--();
    constexpr /*iterator*/ operator--(int);
    constexpr /*iterator*/& operator+=(difference_type n);
    constexpr /*iterator*/& operator-=(difference_type n);
    constexpr const T& operator[](difference_type n) const noexcept;
    friend constexpr bool operator==(const /*iterator*/& x, const /*iterator*/& y);
    friend constexpr auto operator<=>(const /*iterator*/& x, const /*iterator*/& y);
    friend constexpr /*iterator*/ operator+(/*iterator*/ i, difference_type n);
    friend constexpr /*iterator*/ operator+(difference_type n, /*iterator*/ i);
    friend constexpr /*iterator*/ operator-(/*iterator*/ i, difference_type n);
    friend constexpr difference_type operator-(const /*iterator*/& x,
                                               const /*iterator*/& y);
  };
}

namespace std::ranges {
  template<class Val, class CharT, class Traits>
  concept /*stream-extractable*/ = // 説明専用
    requires(basic_istream<CharT, Traits>& is, Val& t) { is >> t; };
  template<movable Val, class CharT, class Traits = char_traits<CharT>>
    requires default_initializable<Val> && /*stream-extractable*/<Val, CharT, Traits>
  class basic_istream_view : public view_interface<basic_istream_view<Val, CharT, Traits>>
  {
  public:
    constexpr explicit basic_istream_view(basic_istream<CharT, Traits>& stream);
    constexpr auto begin()
    {
      */*stream_*/ >> /*value_*/;
      return /*iterator*/{ *this };
    }
    constexpr default_sentinel_t end() const noexcept;
  private:
    // クラス basic_istream_view::iterator
    struct /*iterator*/;                       // 説明専用
    basic_istream<CharT, Traits>* /*stream_*/; // 説明専用
    Val /*value_*/ = Val();                    // 説明専用
  };
}

namespace std::ranges {
  template<movable Val, class CharT, class Traits>
    requires default_initializable<Val> && /*stream-extractable*/<Val, CharT, Traits>
  class basic_istream_view<Val, CharT, Traits>::/*iterator*/
  {
  public:
    using iterator_concept = input_iterator_tag;
    using difference_type  = ptrdiff_t;
    using value_type       = Val;
    constexpr explicit /*iterator*/(basic_istream_view& parent) noexcept;
    /*iterator*/(const /*iterator*/&)            = delete;
    /*iterator*/(/*iterator*/&&)                 = default;
    /*iterator*/& operator=(const /*iterator*/&) = delete;
    /*iterator*/& operator=(/*iterator*/&&)      = default;
    /*iterator*/& operator++();
    void operator++(int);
    Val& operator*() const;
    friend bool operator==(const /*iterator*/& x, default_sentinel_t);
  private:
    basic_istream_view* /*parent_*/; // 説明専用
  };
}

namespace std::ranges {
  template<range R>
    requires is_object_v<R>
  class ref_view : public view_interface<ref_view<R>>
  {
  private:
    R* /*r_*/; // 説明専用
  public:
    template</*different-from*/<ref_view> T>
      requires /* 説明を参照 */
      constexpr
    ref_view(T&& t);
    constexpr R& base() const { return */*r_*/; }
    constexpr iterator_t<R> begin() const { return ranges::begin(*/*r_*/); }
    constexpr sentinel_t<R> end() const { return ranges::end(*/*r_*/); }
    constexpr bool empty() const
      requires requires { ranges::empty(*/*r_*/); }
    {
      return ranges::empty(*/*r_*/);
    }
    constexpr auto size() const
      requires sized_range<R>
    {
      return ranges::size(*/*r_*/);
    }
    constexpr auto reserve_hint() const
      requires approximately_sized_range<R>
    {
      return ranges::reserve_hint(*/*r_*/);
    }
    constexpr auto data() const
      requires contiguous_range<R>
    {
      return ranges::data(*/*r_*/);
    }
  };
  template<class R>
  ref_view(R&) -> ref_view<R>;
}