Compiler Explorer

Source code

#include <algorithm>
#include <compare>
#include <concepts>
#include <functional>
#include <tuple>
#include <ranges>
#include <boost/mp11.hpp>
#include <fmt/format.h>
#include <fmt/ranges.h>

#define FWD(e) static_cast<decltype(e)&&>(e)

// lambda2
#ifndef BOOST_LAMBDA2_LAMBDA2_HPP_INCLUDED
#define BOOST_LAMBDA2_LAMBDA2_HPP_INCLUDED

// Copyright 2020 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

#include <functional>
#include <type_traits>
#include <utility>

namespace boost
{
namespace lambda2
{

namespace detail
{

template<class T> using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;

template<class T, class T2 = remove_cvref_t<T>> using is_lambda_expression =
 std::integral_constant<bool, std::is_placeholder<T2>::value || std::is_bind_expression<T2>::value>;

template<class A> using enable_unary_lambda =
 std::enable_if_t<is_lambda_expression<A>::value>;

template<class A, class B> using enable_binary_lambda =
 std::enable_if_t<is_lambda_expression<A>::value || is_lambda_expression::value>;

} // namespace detail

#define BOOST_LAMBDA2_UNARY_LAMBDA(op, fn) \
 template<class A, class = detail::enable_unary_lambda<A>> \
 auto operator op( A&& a ) \
 { \
 return std::bind( std::fn<>(), std::forward<A>(a) ); \
 }

#define BOOST_LAMBDA2_BINARY_LAMBDA(op, fn) \
 template<class A, class B, class = detail::enable_binary_lambda<A, B>> \
 auto operator op( A&& a, B&& b ) \
 { \
 return std::bind( std::fn<>(), std::forward<A>(a), std::forward(b) ); \
 }

BOOST_LAMBDA2_BINARY_LAMBDA(+, plus)
BOOST_LAMBDA2_BINARY_LAMBDA(-, minus)
BOOST_LAMBDA2_BINARY_LAMBDA(*, multiplies)
BOOST_LAMBDA2_BINARY_LAMBDA(/, divides)
BOOST_LAMBDA2_BINARY_LAMBDA(%, modulus)
BOOST_LAMBDA2_UNARY_LAMBDA(-, negate)

BOOST_LAMBDA2_BINARY_LAMBDA(==, equal_to)
BOOST_LAMBDA2_BINARY_LAMBDA(!=, not_equal_to)
BOOST_LAMBDA2_BINARY_LAMBDA(>, greater)
BOOST_LAMBDA2_BINARY_LAMBDA(<, less)
BOOST_LAMBDA2_BINARY_LAMBDA(>=, greater_equal)
BOOST_LAMBDA2_BINARY_LAMBDA(<=, less_equal)

BOOST_LAMBDA2_BINARY_LAMBDA(&&, logical_and)
BOOST_LAMBDA2_BINARY_LAMBDA(||, logical_or)
BOOST_LAMBDA2_UNARY_LAMBDA(!, logical_not)

BOOST_LAMBDA2_BINARY_LAMBDA(&, bit_and)
BOOST_LAMBDA2_BINARY_LAMBDA(|, bit_or)
BOOST_LAMBDA2_BINARY_LAMBDA(^, bit_xor)
BOOST_LAMBDA2_UNARY_LAMBDA(~, bit_not)

#undef BOOST_LAMBDA2_UNARY_LAMBDA
#undef BOOST_LAMBDA2_BINARY_LAMBDA

using namespace std::placeholders;

} // namespace lambda2
} // namespace boost

#endif // #ifndef BOOST_LAMBDA2_LAMBDA2_HPP_INCLUDED

namespace boost::lambda2 {
 // maybe we should add these as function objects to std?
 // redefining this from Boost.Lambda2 to both declare new function objects and use them
 #define BOOST_LAMBDA2_UNARY_LAMBDA(op, fn) \
 struct fn { constexpr auto operator()(auto&& arg) -> decltype(op FWD(arg)) { return op FWD(arg); } }; \
 template<class A, class = detail::enable_unary_lambda<A>> \
 auto operator op( A&& a ) \
 { \
 return std::bind( fn(), std::forward<A>(a) ); \
 }

#define BOOST_LAMBDA2_BINARY_LAMBDA(op, fn) \
 struct fn { constexpr auto operator()(auto&& x, auto&& y) -> decltype(FWD(x) op FWD(y)) { return FWD(x) op FWD(y); } }; \
 template<class A, class B, class = detail::enable_binary_lambda<A, B>> \
 auto operator op( A&& a, B&& b ) \
 { \
 return std::bind( fn(), std::forward<A>(a), std::forward(b) ); \
 }

BOOST_LAMBDA2_UNARY_LAMBDA(*, deref)
    BOOST_LAMBDA2_UNARY_LAMBDA(++, prefix_inc)
    BOOST_LAMBDA2_UNARY_LAMBDA(--, prefix_dec)
    BOOST_LAMBDA2_BINARY_LAMBDA(+=, plus_eq)
    BOOST_LAMBDA2_BINARY_LAMBDA(-=, minus_eq)

struct index { constexpr auto operator()(auto&& x, auto&& y) -> decltype(FWD(x)[FWD(y)]) { return FWD(x)[FWD(y)]; } };

template <int I> struct placeholder {
 constexpr auto operator[](auto&& arg) const { return std::bind(index(), *this, FWD(arg)); }
 };
 inline constexpr placeholder<1> _{};
}

namespace std {
 template <int I> struct is_placeholder<boost::lambda2::placeholder> : true_type { };
}

namespace std {
 // did I really not think to add this one?
 template <typename... Ts>
 using common_comparison_category_for = common_comparison_category_t<compare_three_way_result_t<Ts>...>;
}

#define FOR_EACH_QUAL(X) X(&) X(const&) X(&&) X(const&&)
using namespace boost::mp11;
using namespace boost::lambda2;

template <size_t N>
inline constexpr auto idx_all_of = [](auto f) -> bool {
 return [=]<size_t... Is>(std::index_sequence<Is...>){
 return (f(mp_size_t<Is>()) and ...);
 }(std::make_index_sequence<N>());
};

template <size_t N>
inline constexpr auto idx_any_of = [](auto f) -> bool {
 return [=]<size_t... Is>(std::index_sequence<Is...>){
 return (f(mp_size_t<Is>()) or ...);
 }(std::make_index_sequence<N>());
};

////////////////////////////////////////////////////////////////////////////////
// Pair
////////////////////////////////////////////////////////////////////////////////
namespace X {
 template <typename T, typename U>
 struct Pair {
 T first;
 U second;

constexpr Pair() = default;

template <typename T1, typename U1>
 requires std::constructible_from<T, T1> and std::constructible_from<U, U1>
 constexpr Pair(T1&& t, U1&& u)
 : first(FWD(t))
 , second(FWD(u))
 { }

#define FROM_PAIR(q) \
 template <typename T1, typename U1> \
 requires std::constructible_from<T, T1 q> and std::constructible_from<U, U1 q> \
 constexpr Pair(Pair<T1, U1> q rhs) \
 : first(FWD(rhs).first) \
 , second(FWD(rhs).second) \
 { } \
 \
 template <typename T1, typename U1> \
 requires std::is_assignable_v<T&, T1 q> and std::is_assignable_v<U&, U1 q> \
 constexpr auto operator=(Pair<T1, U1> q rhs) -> Pair& { \
 first = FWD(rhs).first; \
 second = FWD(rhs).second; \
 return *this; \
 } \
 \
 template <typename T1, typename U1> \
 requires std::is_assignable_v<T const&, T1 q> and std::is_assignable_v \
 constexpr auto operator=(Pair<T1, U1> q rhs) const -> Pair const& { \
 first = FWD(rhs).first; \
 second = FWD(rhs).second; \
 return *this; \
 }
 FOR_EACH_QUAL(FROM_PAIR)
 #undef FROM_PAIR

Pair(Pair const&) = default;
        Pair(Pair&&) = default;

constexpr auto operator=(Pair const& rhs) -> Pair&
 requires std::is_copy_assignable_v<T> && std::is_copy_assignable_v
 {
 first = rhs.first;
 second = rhs.second;
 return *this;
 }

constexpr auto operator=(Pair&& rhs) -> Pair&
 requires std::is_move_assignable_v<T> && std::is_move_assignable_v
 {
 first = std::move(rhs).first;
 second = std::move(rhs).second;
 return *this;
 }

#define GETTER(q) \
 template <size_t I> \
 constexpr decltype(auto) get(mp_size_t = {}) q { \
 if constexpr (I == 0) return static_cast<T q>(first); \
 else return static_cast(second); \
 }
 FOR_EACH_QUAL(GETTER)
 #undef GETTER

#define APPLY(q) \
 template <typename F> \
 constexpr decltype(auto) apply(F&& f) q { \
 return std::invoke(FWD(f), static_cast<T q>(first), static_cast(second)); \
 }
 FOR_EACH_QUAL(APPLY)
 #undef APPLY

friend constexpr void swap(Pair& lhs, Pair& rhs)
 requires std::is_swappable_v<T> and std::is_swappable_v
 {
 std::ranges::swap(lhs.first, rhs.first);
 std::ranges::swap(lhs.second, rhs.second);
 }

friend constexpr void swap(Pair const& lhs, Pair const& rhs)
 requires std::is_swappable_v<T const> and std::is_swappable_v
 {
 std::ranges::swap(lhs.first, rhs.first);
 std::ranges::swap(lhs.second, rhs.second);
 }

constexpr auto operator==(Pair const& rhs) const -> bool
 requires std::equality_comparable<T> and std::equality_comparable
 {
 return first == rhs.first and second == rhs.second;
 }

constexpr auto operator<=>(Pair const& rhs) const
 requires std::three_way_comparable<T> and std::three_way_comparable
 {
 using R = std::common_comparison_category_for<T, U>;
 if (auto c = first <=> rhs.first; c != 0) return R(c);
 return R(second <=> rhs.second);
 }
 };

template <typename T, typename U> Pair(T, U) -> Pair<T, U>;
}

namespace std {
 template <typename T1, typename U1, typename T2, typename U2,
 template <typename> class Qual1,
 template <typename> class Qual2>
 requires requires {
 typename X::Pair<common_reference_t<Qual1<T1>, Qual2<T2>>, common_reference_t<Qual1<U1>, Qual2<U2>>>;
 }
 struct basic_common_reference<X::Pair<T1,U1>, X::Pair<T2,U2>, Qual1, Qual2>
 {
 using type = X::Pair<
 common_reference_t<Qual1<T1>, Qual2<T2>>,
 common_reference_t<Qual1<U1>, Qual2<U2>>
 >;
 };

template <typename T1, typename U1, typename T2, typename U2>
 requires requires { typename X::Pair<common_type_t<T1, U1>, common_type_t<T2, U2>>; }
 struct common_type<X::Pair<T1, T2>, X::Pair<U1, U2>> {
 using type = X::Pair<common_type_t<T1, U1>, common_type_t<T2, U2>>;
 };

template <typename T, typename U> struct tuple_size<X::Pair<T, U>> : mp_size_t<2> { };
 template <size_t I, typename T, typename U> struct tuple_element<I, X::Pair<T, U>> { using type = mp_at_c<X::Pair<T, U>, I>; };
}

////////////////////////////////////////////////////////////////////////////////
// Tuple
////////////////////////////////////////////////////////////////////////////////
namespace X {
 template <typename... Ts>
 class Tuple {
 std::tuple<Ts...> impl;

template <size_t... Is, typename Rhs>
 constexpr Tuple(std::index_sequence<Is...>, Rhs&& tuple)
 : impl(std::get<Is>(FWD(tuple))...)
 { }

template <typename...> friend class Tuple;

public:
        constexpr Tuple() = default;

template <typename... Us> requires (std::constructible_from<Ts, Us> and ...)
 constexpr Tuple(Us&&... us) : impl(FWD(us)...) { }

#define FROM_TUPLE(q) \
 template <typename... Us> \
 requires (std::constructible_from<Ts, Us q> and ...) \
 constexpr Tuple(Tuple<Us...> q rhs) \
 : Tuple(std::index_sequence_for<Ts...>(), FWD(rhs).impl) \
 { } \
 \
 template <typename... Us> \
 requires (std::is_assignable_v<Ts&, Us q> and ...) \
 constexpr auto operator=(Tuple<Us...> q rhs) -> Tuple& { \
 mp_for_each<mp_iota_c<sizeof...(Ts)>>([&](auto I){ \
 std::get(*this) = std::get(FWD(rhs)); \
 }); \
 return *this; \
 } \
 \
 template <typename... Us> \
 requires (std::is_assignable_v<Ts const&, Us q> and ...) \
 constexpr auto operator=(Tuple<Us...> q rhs) const -> Tuple const& { \
 mp_for_each<mp_iota_c<sizeof...(Ts)>>([&](auto I){ \
 std::get(*this) = std::get(FWD(rhs)); \
 }); \
 return *this; \
 }
 FOR_EACH_QUAL(FROM_TUPLE)
 #undef FROM_TUPLE

#define FROM_PAIR(q) \
 template <typename T, typename U> \
 requires (sizeof...(Ts) == 2) \
 and std::constructible_from<mp_defer<mp_first, Tuple>, T q> \
 and std::constructible_from<mp_defer<mp_second, Tuple>, U q> \
 constexpr Tuple(Pair<T, U> q rhs) : impl(FWD(rhs).first, FWD(rhs).second) { }
 FOR_EACH_QUAL(FROM_PAIR)
 #undef FROM_PAIR

#define GETTER(q) \
 template <size_t I> \
 constexpr decltype(auto) get(mp_size_t = {}) q { \
 return std::get(static_cast<std::tuple<Ts...> q>(impl)); \
 }
 FOR_EACH_QUAL(GETTER)
 #undef GETTER

#define APPLY(q) template <typename F> constexpr decltype(auto) apply(F&& f) q { return std::apply(FWD(f), static_cast<std::tuple<Ts...> q>(impl)); }
 FOR_EACH_QUAL(APPLY)
 #undef APPLY

friend constexpr void swap(Tuple& lhs, Tuple& rhs)
 requires (std::is_swappable_v<Ts> and ...)
 {
 mp_for_each<mp_iota_c<sizeof...(Ts)>>([&](auto I){
 std::ranges::swap(std::get(lhs.impl), std::get(rhs.impl));
 });
 }

friend constexpr void swap(Tuple const& lhs, Tuple const& rhs)
 requires (std::is_swappable_v<Ts const> and ...)
 {
 mp_for_each<mp_iota_c<sizeof...(Ts)>>([&](auto I){
 std::ranges::swap(std::get(lhs.impl), std::get(rhs.impl));
 });
 }

template <typename... Us>
 constexpr auto operator==(Tuple<Us...> const& rhs) const -> bool
 requires (std::equality_comparable_with<Ts, Us> and ...)
 {
 return impl == rhs.impl;
 }

constexpr auto operator<=>(Tuple const& rhs) const
 requires (std::three_way_comparable<Ts> and ...)
 {
 return impl <=> rhs.impl;
 }
 };

template <typename... Ts> Tuple(Ts...) -> Tuple<Ts...>;

template <size_t I, typename Tuple> constexpr auto get(Tuple&& tuple) { return FWD(tuple).get(mp_size_t()); }
}

namespace std {
 template <typename... Ts, typename... Us,
 template <typename> class TQual,
 template <typename> class UQual>
 requires requires { typename X::Tuple<common_reference_t<TQual<Ts>, UQual<Us>>...>; }
 struct basic_common_reference<X::Tuple<Ts...>, X::Tuple<Us...>, TQual, UQual>
 {
 using type = X::Tuple<common_reference_t<TQual<Ts>, UQual<Us>>...>;
 };

template <typename... Ts, typename... Us>
 requires requires { typename X::Tuple<common_type_t<Ts, Us>...>; }
 struct common_type<X::Tuple<Ts...>, X::Tuple<Us...>> {
 using type = X::Tuple<common_type_t<Ts, Us>...>;
 };

template <typename... Ts> struct tuple_size<X::Tuple<Ts...>> : mp_size_t<sizeof...(Ts)> { };
 template <size_t I, typename... Ts> struct tuple_element<I, X::Tuple<Ts...>> { using type = mp_at_c<X::Tuple<Ts...>, I>; };
}

////////////////////////////////////////////////////////////////////////////////
// Array
////////////////////////////////////////////////////////////////////////////////
namespace X {
 template <typename T, std::size_t N>
 struct Array : std::array<T, N> {
 #define APPLY(q) \
 template <typename F> \
 constexpr decltype(auto) apply(F&& f) q { \
 return std::apply(FWD(f), static_cast<std::array<T, N> q>(*this)); \
 }
 FOR_EACH_QUAL(APPLY)
 #undef APPLY
 };
}

////////////////////////////////////////////////////////////////////////////////
// zip
////////////////////////////////////////////////////////////////////////////////

namespace std::ranges {
 template <typename... Rs>
 concept zip_is_common =
 (sizeof...(Rs) == 1 and (common_range<Rs> and ...))
 or (not (bidirectional_range<Rs> and ...) and (common_range<Rs> and ...))
 or ((random_access_range<Rs> and ...) and (sized_range<Rs> and ...));

template <typename... Ts>
 using tuple_or_pair = mp_eval_if_c<sizeof...(Ts) != 2, X::Tuple<Ts...>, X::Pair, Ts...>;

static_assert(std::same_as<tuple_or_pair<int>, X::Tuple<int>>);
 static_assert(std::same_as<tuple_or_pair<int, char>, X::Pair<int, char>>);
 static_assert(std::same_as<tuple_or_pair<int, char, float>, X::Tuple<int, char, float>>);

template <typename F, typename Tuple>
 constexpr auto tuple_transform(F&& f, Tuple&& tuple) {
 return FWD(tuple).apply([&]<typename... Ts>(Ts&&... elems){
 return tuple_or_pair<invoke_result_t<F&, Ts>...>(
 std::invoke(f, FWD(elems))...
 );
 });
 }

static_assert(tuple_transform([](auto i){ return i+1; }, X::Tuple(0, 1, 2)) == X::Tuple(1, 2, 3));
    static_assert(tuple_transform([](auto i){ return i+1; }, X::Tuple(0, 1)) == X::Pair(1, 2));
    static_assert(tuple_transform([](auto i){ return i+1; }, X::Pair(0, 1)) == X::Pair(1, 2));

template <typename F, typename Tuple>
 constexpr void tuple_for_each(F&& f, Tuple&& tuple) {
 FWD(tuple).apply([&](auto&&... elems){
 (std::invoke(f, FWD(elems)), ...);
 });
 }

template <typename R> concept simple_view = __detail::__simple_view<R>;

// if C is false, empty type. Otherwise, iterator_category is F<T...>
 template <bool C, template <typename...> class F, typename... T> struct maybe_iterator_category { };
 template <template <typename...> class F, typename... T> struct maybe_iterator_category<true, F, T...> { using iterator_category = F<T...>; };

template <bool B, typename T> using maybe_const = __detail::__maybe_const_t<B, T>;

template <input_range... Views>
 requires (view<Views> and ...) and (sizeof...(Views) > 0)
 class zip_view : public view_interface<zip_view<Views...>> {
 X::Tuple<Views...> views_;
 template <bool> class iterator;
 template <bool> class sentinel;

template <bool Const>
 class iterator : public maybe_iterator_category<(forward_range<Views> and ...), mp_identity_t, input_iterator_tag>
 {
 friend zip_view;
 template <bool> friend class sentinel;

tuple_or_pair<iterator_t<maybe_const<Const, Views>>...> current_;
 constexpr explicit iterator(tuple_or_pair<iterator_t<maybe_const<Const, Views>>...> current)
 : current_(std::move(current))
 { }
 public:
 using iterator_concept = mp_cond<
 mp_bool<(random_access_range<Views> and ...)>, random_access_iterator_tag,
 mp_bool<(bidirectional_range<Views> and ...)>, bidirectional_iterator_tag,
 mp_bool<(forward_range<Views> and ...)>, forward_iterator_tag,
 mp_true, input_iterator_tag
 >;
 using value_type = tuple_or_pair<range_value_t<maybe_const<Const, Views>>...>;
 using reference = tuple_or_pair<range_reference_t<maybe_const<Const, Views>>...>;
 using difference_type = common_type_t<range_difference_t<maybe_const<Const, Views>>...>;

iterator() = default;
 constexpr iterator(iterator<!Const> i) requires Const && (convertible_to<iterator_t<Views>, iterator_t<maybe_const<Const, Views>>> and ...)
 : current_(std::move(i).current_)
 { }

constexpr auto operator*() const -> reference {
 return tuple_transform(*_, current_);
 }
 constexpr auto operator++() -> iterator& {
 tuple_for_each(++_, current_);
 return *this;
 }
 constexpr void operator++(int) { ++*this; }
 constexpr auto operator++(int) -> iterator requires (forward_range<maybe_const<Const, Views>> and ...) {
 auto tmp = *this;
 ++*this;
 return tmp;
 }

constexpr auto operator--() -> iterator& requires (bidirectional_range<maybe_const<Const, Views>> and ...) {
 tuple_for_each(--_, current_);
 return *this;
 }
 constexpr auto operator--(int) -> iterator requires (bidirectional_range<maybe_const<Const, Views>> and ...) {
 auto tmp = *this;
 --*this;
 return tmp;
 }

constexpr auto operator+=(difference_type x) -> iterator& requires (random_access_range<maybe_const<Const, Views>> and ...) {
 tuple_for_each(_ += x, current_);
 return *this;
 }
 constexpr auto operator-=(difference_type x) -> iterator& requires (random_access_range<maybe_const<Const, Views>> and ...) {
 tuple_for_each(_ -= x, current_);
 return *this;
 }
 constexpr auto operator[](difference_type x) const -> reference requires (random_access_range<maybe_const<Const, Views>> and ...) {
 return tuple_transform(_[x], current_);
 }

constexpr auto operator==(iterator const& rhs) const -> bool requires (equality_comparable<iterator_t<maybe_const<Const, Views>>> and ...) {
 if constexpr ((bidirectional_range<maybe_const<Const, Views>> && ...)) {
 return current_ == rhs.current_;
 } else {
 return idx_any_of<sizeof...(Views)>([&](auto I){ return current_.get(I) == rhs.current_.get(I); });
 }
 }
 constexpr auto operator<=>(iterator const& rhs) const requires (random_access_range<maybe_const<Const, Views>> and ...)
 and (three_way_comparable<iterator_t<maybe_const<Const, Views>>> and ...)
 {
 return current_ <=> rhs.current_;
 }

friend constexpr auto operator+(iterator const& i, difference_type n) -> iterator requires (random_access_range<maybe_const<Const, Views>> and ...) {
 return iterator(tuple_transform(_ + n, i.current_));
 }
 friend constexpr auto operator+(difference_type n, iterator const& i) -> iterator requires (random_access_range<maybe_const<Const, Views>> and ...) {
 return iterator(tuple_transform(_ + n, i.current_));
 }
 friend constexpr auto operator-(iterator const& i, difference_type n) -> iterator requires (random_access_range<maybe_const<Const, Views>> and ...) {
 return iterator(tuple_transform(_ - n, i.current_));
 }
 friend constexpr auto operator-(iterator const& x, iterator const& y) -> difference_type requires (sized_sentinel_for<iterator_t<maybe_const<Const, Views>>, iterator_t<maybe_const<Const, Views>>> and ...) {
 return [&]<size_t... Is>(std::index_sequence<Is...>){
 return ranges::min(
 {difference_type(x.current_.get(mp_size_t<Is>()) - y.current_.get(mp_size_t<Is>()))...},
 std::ranges::less(),
 [](auto x){ return std::abs(x); }
 );
 }(std::index_sequence_for<Views...>());
 }

friend constexpr auto iter_move(iterator const& i) {
                return tuple_transform(ranges::iter_move, i.current_);
            }

friend constexpr void iter_swap(iterator const& x, iterator const& y) {
 mp_for_each<mp_iota_c<sizeof...(Views)>>([&](auto I){
 ranges::iter_swap(x.get(I), y.get(I));
 });
 }

// for other views
 template <typename F>
 constexpr auto apply(F&& f) const -> decltype(auto) {
 return current_.apply(FWD(f));
 }
 };

template <bool Const>
 class sentinel {
 friend zip_view;
 tuple_or_pair<sentinel_t<maybe_const<Const, Views>>...> end_;
 constexpr explicit sentinel(tuple_or_pair<sentinel_t<maybe_const<Const, Views>>...> end) : end_(std::move(end)) { }
 public:
 sentinel() = default;
 constexpr sentinel(sentinel<!Const> i) requires Const && (convertible_to<sentinel_t<Views>, sentinel_t<maybe_const<Const, Views>>> and ...)
 : end_(std::move(i).end_)
 { }

template <bool OtherConst>
 requires (sentinel_for<sentinel_t<maybe_const<Const, Views>>, iterator_t<maybe_const<OtherConst, Views>>> and ...)
 constexpr auto operator==(iterator<OtherConst> const& x) const -> bool {
 return idx_any_of<sizeof...(Views)>([&](auto I) -> bool { return x.current_.get(I) == end_.get(I); });
 }

template <bool OtherConst>
 requires (sized_sentinel_for<sentinel_t<maybe_const<Const, Views>>, iterator_t<maybe_const<OtherConst, Views>>> and ...)
 friend constexpr auto operator-(iterator<OtherConst> const& x, sentinel const& y) -> common_type_t<range_difference_t<maybe_const<OtherConst, Views>>...> {
 using R = common_type_t<range_difference_t<maybe_const<OtherConst, Views>>...>;
 return [&]<size_t... Is>(std::index_sequence<Is...>){
 return ranges::min(
 {R(x.current_.get(mp_size_t<Is>()) - y.end_.get(mp_size_t<Is>()))...},
 std::ranges::less(),
 [](auto x){ return std::abs(x); }
 );
 }(std::index_sequence_for<Views...>());
 }

public:
        constexpr zip_view() = default;
        constexpr explicit zip_view(Views... views) : views_(std::move(views)...) {}

constexpr auto begin() -> iterator<false> requires (not (simple_view<Views> and ...)) {
 return iterator<false>(tuple_transform(ranges::begin, views_));
 }
 constexpr auto begin() const -> iterator<true> requires (range<Views const> and ...) {
 return iterator<true>(tuple_transform(ranges::begin, views_));
 }

constexpr auto end() -> sentinel<false> requires (not (simple_view<Views> and ...) and not zip_is_common<Views...>) {
 return sentinel<false>(tuple_transform(ranges::end, views_));
 }
 constexpr auto end() -> iterator<false> requires (not (simple_view<Views> and ...) and zip_is_common<Views...>) {
 if constexpr ((random_access_range<Views> and ...)) {
 return begin() + size();
 } else {
 return iterator<false>(tuple_transform(ranges::end, views_));
 }
 }
 constexpr auto end() const -> sentinel<true> requires ((range<Views const> and ...) and not zip_is_common<Views...>) {
 return sentinel<true>(tuple_transform(ranges::end, views_));
 }
 constexpr auto end() const -> iterator<true> requires ((range<Views const> and ...) and zip_is_common<Views...>) {
 if constexpr ((random_access_range<Views> and ...)) {
 return begin() + size();
 } else {
 return iterator<true>(tuple_transform(ranges::end, views_));
 }
 }

constexpr auto size() requires (sized_range<Views> and ...) {
 return tuple_transform(ranges::size, views_).apply([]<typename... I>(I... sizes){
 return ranges::min({common_type_t<I...>(sizes)...});
 });
 }
 constexpr auto size() const requires (sized_range<Views const> and ...) {
 return tuple_transform(ranges::size, views_).apply([]<typename... I>(I... sizes){
 return ranges::min({common_type_t<I...>(sizes)...});
 });
 }
 };

template <class... Rs> zip_view(Rs&&... rs) -> zip_view<views::all_t<Rs>...>;

namespace views {
 inline constexpr auto zip = []<viewable_range... Rs>(Rs&&... rs) {
 if constexpr (sizeof...(Rs) == 0){
 return views::empty<X::Tuple<>>;
 } else {
 return zip_view<all_t<Rs>...>(FWD(rs)...);
 }
 };
 }
}

////////////////////////////////////////////////////////////////////////////////
// zip_transform
////////////////////////////////////////////////////////////////////////////////

namespace std::ranges {
 template <copy_constructible F, input_range... Views>
 requires (view<Views> and ...) and (sizeof...(Views) > 0) and is_object_v<F>
 and regular_invocable<F&, range_reference_t<Views>...>
 and std::__detail::__can_reference<invoke_result_t<F&, range_reference_t<Views>...>>
 class zip_transform_view : public view_interface<zip_transform_view<F, Views...>> {
 [[no_unique_address]] __detail::__box<F> fun_;
 zip_view<Views...> zip_;

using InnerView = zip_view<Views...>;
 template <bool Const>
 using ziperator = iterator_t<maybe_const<Const, InnerView>>;
 template <bool Const>
 using zentinel = sentinel_t<maybe_const<Const, InnerView>>;

template <bool> class iterator;
 template <bool> class sentinel;

template <typename T> using nested_iterator_category = typename T::iterator_category;
 template <typename I> using iterator_category_for = mp_eval_or<std::input_iterator_tag, nested_iterator_category, iterator_traits>;
 template <bool Const> using categories = mp_list<iterator_category_for<iterator_t<maybe_const<Const, Views>>>...>;
 template <bool Const, typename Tag> using all_categories_derive_from = mp_all_of_q<categories<Const>, mp_bind_front<is_base_of, Tag>>;

template <bool Const> using result_type = invoke_result_t<maybe_const<Const, F>&, range_reference_t<maybe_const<Const, Views>>...>;

template <bool Const>
 class iterator : public maybe_iterator_category<
 // only present if Base models forward_range
 forward_range<maybe_const<Const, InnerView>>,
 mp_cond,
 mp_bool<!is_lvalue_reference_v<result_type<Const>>>, input_iterator_tag,
 all_categories_derive_from<Const, random_access_iterator_tag>, random_access_iterator_tag,
 all_categories_derive_from<Const, bidirectional_iterator_tag>, bidirectional_iterator_tag,
 all_categories_derive_from<Const, forward_iterator_tag>, forward_iterator_tag,
 mp_true, input_iterator_tag>
 {
 friend zip_transform_view;
 using Parent = maybe_const<Const, zip_transform_view>;
 using Base = maybe_const<Const, InnerView>;
 Parent* parent_ = nullptr;
 ziperator<Const> inner_;

constexpr iterator(Parent& parent, ziperator<Const> inner)
 : parent_(&parent)
 , inner_(std::move(inner))
 { }
 public:
 using iterator_concept = typename ziperator<Const>::iterator_concept;
 using reference = result_type<Const>;
 using value_type = remove_cvref_t<reference>;
 using difference_type = range_difference_t<Base>;

iterator() = default;
 constexpr iterator(iterator<!Const> i) requires Const && convertible_to<ziperator<false>, ziperator<Const>>
 : parent_(i.parent_)
 , inner_(std::move(i.inner_))
 { }

constexpr auto operator*() const -> reference {
                return inner_.apply([&](auto const&... iters) -> decltype(auto) {
                    return std::invoke(*parent_->fun_, *iters...);
                });
            }

constexpr auto operator++() -> iterator& {
 ++inner_;
 return *this;
 }
 constexpr void operator++(int) {
 ++*this;
 }
 constexpr auto operator++(int) -> iterator requires forward_range<Base> {
 auto tmp = *this;
 ++*this;
 return tmp;
 }

constexpr auto operator--() -> iterator& requires bidirectional_range<Base> {
 --inner_;
 return *this;
 }
 constexpr auto operator--(int) -> iterator requires bidirectional_range<Base> {
 auto tmp = *this;
 --*this;
 return tmp;
 }

constexpr auto operator+=(difference_type x) -> iterator& requires random_access_range<Base> {
 inner_ += x;
 return *this;
 }
 constexpr auto operator-=(difference_type x) -> iterator& requires random_access_range<Base> {
 inner_ -= x;
 return *this;
 }
 constexpr auto operator[](difference_type x) const -> reference requires random_access_range<Base> {
 return inner_.apply([&](auto const&... iters) -> decltype(auto) {
 return std::invoke(*parent_->fun_, iters[x]...);
 });
 }

constexpr auto operator==(iterator const& rhs) const -> bool requires equality_comparable<ziperator<Const>> {
 return inner_ == rhs.inner_;
 }
 constexpr auto operator<=>(iterator const& rhs) const requires random_access_range<Base> && three_way_comparable<ziperator<Const>> {
 return inner_ <=> rhs.inner_;
 }

friend constexpr auto operator+(iterator const& i, difference_type n) -> iterator requires random_access_range<Base> {
 return iterator(*i.parent_, i.inner_ + n);
 }
 friend constexpr auto operator+(difference_type n, iterator const& i) -> iterator requires random_access_range<Base> {
 return iterator(*i.parent_, i.inner_ + n);
 }
 friend constexpr auto operator-(iterator const& i, difference_type n) -> iterator requires random_access_range<Base> {
 return iterator(*i.parent_, i.inner_ - n);
 }
 friend constexpr auto operator-(iterator const& x, iterator const& y) -> difference_type requires sized_sentinel_for<ziperator<Const>, ziperator<Const>> {
 return x.inner_ - y.inner_;
 }
 };

template <bool Const>
 class sentinel {
 friend zip_transform_view;
 zentinel<Const> inner_;
 constexpr explicit sentinel(zentinel<Const> inner) : inner_(std::move(inner)) { }

public:
 sentinel() = default;
 constexpr sentinel(sentinel<!Const> i) requires Const && convertible_to<zentinel<false>, zentinel<Const>>
 : inner_(std::move(i.inner_))
 { }

template <bool OtherConst>
 requires sentinel_for<zentinel<Const>, ziperator<OtherConst>>
 constexpr auto operator==(const iterator<OtherConst>& x) const -> bool {
 return inner_ == x.inner_;
 }

template <bool OtherConst>
 requires sized_sentinel_for<zentinel<Const>, ziperator<OtherConst>>
 friend constexpr auto operator-(const iterator<OtherConst>& x, const sentinel& y) -> range_difference_t<maybe_const<OtherConst, InnerView>> {
 return x.inner_ - y.inner_;
 }

template <bool OtherConst>
 requires sized_sentinel_for<zentinel<Const>, ziperator<OtherConst>>
 friend constexpr auto operator-(const sentinel& x, const iterator<OtherConst>& y) -> range_difference_t<maybe_const<OtherConst, InnerView>> {
 return x.inner_ - y.inner_;
 }
 };

public:
        constexpr zip_transform_view() = default;

constexpr explicit zip_transform_view(F fun, Views... views)
            : fun_(std::move(fun))
            , zip_(std::move(views)...)
        { }

constexpr auto begin() -> iterator<false> {
 return iterator<false>(*this, zip_.begin());
 }
 constexpr auto begin() const -> iterator<true> requires range<InnerView const> && regular_invocable<F const&, range_reference_t<Views const>...> {
 return iterator<true>(*this, zip_.begin());
 }

constexpr auto end() -> sentinel<false> {
 return sentinel<false>(zip_.end());
 }
 constexpr auto end() -> iterator<false> requires common_range<InnerView> {
 return iterator<false>(*this, zip_.end());
 }
 constexpr auto end() const -> sentinel<true> requires range<InnerView const> && regular_invocable<F const&, range_reference_t<Views const>...> {
 return sentinel<true>(zip_.end());
 }
 constexpr auto end() const -> iterator<true> requires common_range<InnerView const> && regular_invocable<F const&, range_reference_t<Views const>...> {
 return iterator<true>(*this, zip_.end());
 }

constexpr auto size() requires sized_range<InnerView> {
 return zip_.size();
 }
 constexpr auto size() const requires sized_range<InnerView const> {
 return zip_.size();
 }
 };

template <typename F, typename... Rs>
 zip_transform_view(F, Rs&&...) -> zip_transform_view<F, views::all_t<Rs>...>;

namespace views {
 inline constexpr auto zip_transform =
 []<typename F, viewable_range... Es, copy_constructible FD = decay_t<F>>
 requires regular_invocable<FD&, range_reference_t<Es>...>
 (F&& f, Es&&... es) {
 if constexpr (sizeof...(Es) == 0) {
 return views::empty<decay_t<invoke_result_t<FD&>>>;
 } else {
 return zip_transform_view(FWD(f), FWD(es)...);
 }
 };
 }
}

////////////////////////////////////////////////////////////////////////////////
// adjacent
////////////////////////////////////////////////////////////////////////////////

namespace std::ranges {
 template <size_t N> concept Positive = (N > 0);

template<typename T, typename Tag = void, bool Enable = true>
 struct non_propagating_cache : optional<T>
 {
 non_propagating_cache() = default;
 constexpr non_propagating_cache(nullopt_t) noexcept {}
 constexpr non_propagating_cache(non_propagating_cache const &) noexcept
 : optional<T>{}
 { }
 constexpr non_propagating_cache(non_propagating_cache&& that) noexcept
 : optional<T>{ }
 {
 that.optional<T>::reset();
 }

constexpr auto operator=(non_propagating_cache const&) noexcept -> non_propagating_cache& {
 optional<T>::reset();
 return *this;
 }

constexpr auto operator=(non_propagating_cache&& that) noexcept -> non_propagating_cache& {
 that.optional<T>::reset();
 optional<T>::reset();
 return *this;
 }

using optional<T>::operator=;
 };

template <input_range V, size_t N>
 requires view<V> and Positive<N>
 class adjacent_view : public view_interface<adjacent_view<V, N>> {
 V base_ = V();

using cache_t = std::array<range_value_t<V>, N>;
 non_propagating_cache<cache_t> cache_ = non_propagating_cache<cache_t>();
 ptrdiff_t index_ = 0;

class iterator;
        class sentinel;
        struct as_sentinel {};

class iterator {
 friend adjacent_view;
 friend sentinel;
 iterator_t<V> current_ = iterator_t<V>();
 adjacent_view* parent_ = nullptr;

constexpr iterator(adjacent_view& parent, iterator_t<V> first, sentinel_t<V> last)
 : current_(std::move(first))
 , parent_(&parent)
 {
 array<optional<range_value_t<V>>, N> objects;
 if (current_ == last) {
 return;
 }
 objects[0].emplace(*current_);

for (size_t i = 1; i != N; ++i) {
                    ++current_;
                    if (current_ == last) {
                        return;
                    }

objects[i].emplace(*current_);
                }

// still here, that means we actually have N elements and can
 // populate our cache
 [&]<size_t... Is>(index_sequence<Is...>){
 parent_->cache_.emplace(cache_t{*objects[Is]...});
 }(make_index_sequence<N>());
 }

constexpr iterator(as_sentinel, iterator_t<V> last)
 : current_(std::move(last))
 { }

public:
 using iterator_category = input_iterator_tag;
 using value_type = mp_apply<tuple_or_pair, mp_repeat_c<mp_list<range_value_t<V>>, N>>;
 using reference = mp_apply<tuple_or_pair, mp_repeat_c<mp_list<range_value_t<V>&>, N>>;
 using difference_type = range_difference_t<V>;

constexpr iterator() = default;

constexpr auto operator*() const -> reference {
 return [&]<size_t... Is>(index_sequence<Is...>) -> reference {
 return reference{(*parent_->cache_)[(parent_->index_ + Is) % N]...};
 }(make_index_sequence<N>());
 }

constexpr auto operator++() -> iterator& {
                ++current_;
                if (current_ != ranges::end(parent_->base_)) {
                    // if we're not at the end yet, stash the value we're at
                    (*parent_->cache_)[(parent_->index_++) % N] = *current_;
                }
                return *this;
            }

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

constexpr auto operator==(iterator const& rhs) const -> bool {
                return current_ == rhs.current_;
            }
        };

class sentinel {
 friend adjacent_view;
 sentinel_t<V> end_ = sentinel_t<V>();
 constexpr sentinel(sentinel_t<V> end) : end_(std::move(end)) { }

public:
            sentinel() = default;

constexpr auto operator==(iterator const& x) const -> bool {
                return x.current_ == end_;
            }
        };

public:
        constexpr adjacent_view() = default;
        constexpr explicit adjacent_view(V base) : base_(std::move(base)) { }

constexpr auto begin() -> iterator {
            return iterator(*this, ranges::begin(base_), ranges::end(base_));
        }

constexpr auto end() -> sentinel {
 return sentinel(ranges::end(base_));
 }
 constexpr auto end() -> iterator requires common_range<V> {
 return iterator(as_sentinel{}, ranges::end(base_));
 }

constexpr auto size() requires sized_range<V> {
 auto sz = ranges::size(base_);
 sz -= std::min<decltype(sz)>(sz, N - 1);
 return sz;
 }
 };

template <forward_range V, size_t N>
 requires view<V> and Positive<N>
 class adjacent_view<V, N> : public view_interface<adjacent_view<V, N>> {
 V base_ = V();

template <bool> class iterator;
 template <bool> class sentinel;
 struct as_sentinel {};

template <bool Const>
 class iterator {
 template <bool> friend class sentinel;
 friend adjacent_view;
 using Base = maybe_const<Const, V>;
 X::Array<iterator_t<Base>, N> current_ = X::Array<iterator_t<Base>, N>();

constexpr iterator(iterator_t<Base> first, sentinel_t<Base> last) {
 current_[0] = first;
 for (size_t i = 1; i != N; ++i) {
 current_[i] = ranges::next(current_[i-1], 1, last);
 }
 }

constexpr iterator(as_sentinel, iterator_t<Base> first, iterator_t<Base> last) {
 if constexpr (bidirectional_range<Base>) {
 current_[N-1] = last;
 for (size_t i=N-1; i >= 1; --i) {
 current_[i-1] = ranges::prev(current_[i], 1, first);
 }
 } else {
 current_.fill(last);
 }
 }

public:
 using iterator_category = input_iterator_tag;
 using iterator_concept = mp_cond<
 mp_bool<random_access_range<V>>, random_access_iterator_tag,
 mp_bool<bidirectional_range<V>>, bidirectional_iterator_tag,
 mp_true, forward_iterator_tag
 >;
 using value_type = mp_apply<tuple_or_pair, mp_repeat_c<mp_list<range_value_t<Base>>, N>>;
 using reference = mp_apply<tuple_or_pair, mp_repeat_c<mp_list<range_reference_t<Base>>, N>>;
 using difference_type = range_difference_t<Base>;

iterator() = default;
 constexpr iterator(iterator<not Const> i) requires Const and convertible_to<iterator_t<V>, iterator_t<Base>>
 : current_(std::move(i).current_)
 { }

constexpr auto operator*() const -> reference {
                return tuple_transform(*_, current_);
            }
            constexpr auto operator++() -> iterator& {
                ranges::copy(current_ | views::drop(1), current_.begin());
                ++current_.back();
                return *this;
            }

constexpr auto operator++(int) -> iterator {
                auto tmp = *this;
                ++*this;
                return tmp;
            }

constexpr auto operator--() -> iterator& requires bidirectional_range<Base> {
 ranges::copy_backward(current_ | views::take(N - 1), current_.end());
 --current_.front();
 return *this;
 }
 constexpr auto operator--(int) -> iterator requires bidirectional_range<Base> {
 auto tmp = *this;
 --*this;
 return tmp;
 }

constexpr auto operator+=(difference_type x) -> iterator& requires random_access_range<Base> {
 ranges::for_each(current_, _ += x);
 return *this;
 }
 constexpr auto operator-=(difference_type x) -> iterator& requires random_access_range<Base> {
 ranges::for_each(current_, _ -= x);
 return *this;
 }
 constexpr auto operator[](difference_type x) const -> reference requires random_access_range<Base> {
 return tuple_transform(_[x], current_);
 }

constexpr auto operator==(iterator const& rhs) const -> bool {
 return current_.back() == rhs.current_.back();
 }
 constexpr auto operator<=>(iterator const& rhs) const requires random_access_range<Base> and three_way_comparable<iterator_t<Base>> {
 return current_.back() <=> rhs.current_.back();
 }

friend constexpr auto operator+(iterator const& i, difference_type n) -> iterator requires random_access_range<Base> {
 auto r = i;
 r += n;
 return r;
 }
 friend constexpr auto operator+(difference_type n, iterator const& i) -> iterator requires random_access_range<Base> {
 return i + n;
 }
 friend constexpr auto operator-(iterator const& i, difference_type n) -> iterator requires random_access_range<Base> {
 auto r = i;
 r -= n;
 return r;
 }
 friend constexpr auto operator-(iterator const& x, iterator const& y) -> difference_type requires sized_sentinel_for<iterator_t<Base>, iterator_t<Base>> {
 return x.current_.back() - y.current_.back();
 }

friend constexpr auto iter_move(iterator const& i) {
 return tuple_transform(ranges::iter_move, i.current_);
 }
 friend constexpr void iter_swap(iterator const& x, iterator const& y) requires indirectly_swappable<iterator_t<Base>> {
 for (size_t i = 0; i != N; ++i) {
 ranges::iter_swap(x.current_[i], y.current_[i]);
 }
 }
 };

template <bool Const>
 class sentinel {
 friend adjacent_view;
 using Base = maybe_const<Const, V>;
 sentinel_t<Base> end_ = sentinel_t<Base>();
 constexpr explicit sentinel(sentinel_t<Base> end) : end_(std::move(end)) { }

public:
 sentinel() = default;
 constexpr sentinel(sentinel<not Const> i) requires Const and convertible_to<sentinel_t<V>, sentinel_t<Base>>
 : end_(std::move(i))
 { }

template <bool OtherConst>
 requires sentinel_for<sentinel_t<Base>, iterator_t<maybe_const<OtherConst, V>>>
 constexpr auto operator==(iterator<OtherConst> const& x) const -> bool {
 return x.current_.back() == end_;
 }

template <bool OtherConst>
 requires sized_sentinel_for<sentinel_t<Base>, iterator_t<maybe_const<OtherConst, V>>>
 friend constexpr auto operator-(iterator<OtherConst> const& x, sentinel const& y) -> range_difference_t<maybe_const<OtherConst, V>> {
 return x.current_.back() - y.end_;
 }

template <bool OtherConst>
 requires sized_sentinel_for<sentinel_t<Base>, iterator_t<maybe_const<OtherConst, V>>>
 friend constexpr auto operator-(sentinel const& y, iterator<OtherConst> const& x) -> range_difference_t<maybe_const<OtherConst, V>> {
 return y.end_ - x.current_.back();
 }
 };

public:
        constexpr adjacent_view() = default;
        constexpr explicit adjacent_view(V base) : base_(std::move(base)) { }

constexpr auto begin() -> iterator<false> requires (!simple_view<V>) {
 return iterator<false>(ranges::begin(base_), ranges::end(base_));
 }
 constexpr auto begin() const -> iterator<true> requires range<V const> {
 return iterator<true>(ranges::begin(base_), ranges::end(base_));
 }

constexpr auto end() -> sentinel<false> requires (!simple_view<V> and !common_range<V>) {
 return sentinel<false>(ranges::end(base_));
 }
 constexpr auto end() -> iterator<false> requires (!simple_view<V> and common_range<V>) {
 return iterator<false>(as_sentinel{}, ranges::begin(base_), ranges::end(base_));
 }
 constexpr auto end() const -> sentinel<true> requires range<V const> {
 return sentinel<true>(ranges::end(base_));
 }
 constexpr auto end() const -> iterator<true> requires common_range<V const> {
 return iterator<true>(as_sentinel{}, ranges::begin(base_), ranges::end(base_));
 }

constexpr auto size() requires sized_range<V> {
 auto sz = ranges::size(base_);
 sz -= std::min<decltype(sz)>(sz, N - 1);
 return sz;
 }
 constexpr auto size() const requires sized_range<V const> {
 auto sz = ranges::size(base_);
 sz -= std::min<decltype(sz)>(sz, N - 1);
 return sz;
 }
 };

namespace views {
 template <size_t N>
 inline constexpr __adaptor::_RangeAdaptorClosure adjacent =
 []<viewable_range R>(R&& r){
 if constexpr (N == 0) {
 return views::empty<X::Tuple<>>;
 } else {
 return adjacent_view<views::all_t<R>, N>(FWD(r));
 }
 };

inline constexpr auto pairwise = adjacent<2>;
 }
}

////////////////////////////////////////////////////////////////////////////////
// adjacent_transform
////////////////////////////////////////////////////////////////////////////////
namespace std::ranges {
 template <forward_range V, copy_constructible F, size_t N,
 typename R = mp_repeat_c<mp_list<V>, N>>
 class adjacent_transform_view;

template <forward_range V, copy_constructible F, size_t N, typename... RepeatV>
 requires view<V>
 and Positive<N>
 and is_object_v<F>
 and regular_invocable<F&, range_reference_t<RepeatV>...>
 and std::__detail::__can_reference<invoke_result_t<F&, range_reference_t<RepeatV>...>>
 class adjacent_transform_view<V, F, N, mp_list<RepeatV...>>
 : public view_interface<adjacent_transform_view<V, F, N, mp_list<RepeatV...>>>
 {
 [[no_unique_address]] __detail::__box<F> fun_;
 adjacent_view<V, N> inner_;

using InnerView = adjacent_view<V, N>;
 template <bool Const> using inner_iterator = iterator_t<maybe_const<Const, InnerView>>;
 template <bool Const> using inner_sentinel = sentinel_t<maybe_const<Const, InnerView>>;

template <bool Const> class iterator;
 template <bool Const> class sentinel;

template <bool Const>
 class iterator {
 friend adjacent_transform_view;
 using Parent = maybe_const<Const, adjacent_transform_view>;
 using Base = maybe_const<Const, V>;
 template <typename T>
 using derived_from_tag = mp_bool<derived_from<
 typename iterator_traits<iterator_t<Base>>::iterator_category, T>>;
 Parent* parent_ = nullptr;
 inner_iterator<Const> inner_ = inner_iterator<Const>();

constexpr iterator(Parent& parent, inner_iterator<Const> inner)
 : parent_(&parent)
 , inner_(std::move(inner))
 { }

public:
 using reference = invoke_result_t<
 maybe_const<Const, F&>, range_reference_t<maybe_const<Const, RepeatV>>...>;
 using value_type = remove_cvref_t<reference>;
 using iterator_category = mp_cond<
 mp_bool<!is_lvalue_reference_v<reference>>, input_iterator_tag,
 derived_from_tag<random_access_iterator_tag>, random_access_iterator_tag,
 derived_from_tag<bidirectional_iterator_tag>, bidirectional_iterator_tag,
 derived_from_tag<forward_iterator_tag>, forward_iterator_tag,
 mp_true, input_iterator_tag>;

using iterator_concept = inner_iterator<Const>::iterator_concept;
 using difference_type = range_difference_t<Base>;

iterator() = default;
 constexpr iterator(iterator<not Const> i) requires Const and convertible_to<inner_iterator<false>, inner_iterator<Const>>
 : parent_(i.parent_)
 , inner_(std::move(i.inner_))
 { }

constexpr auto operator*() const -> reference {
                return inner_.current_.apply([&](auto const&... iters)  -> decltype(auto) {
                    return std::invoke(*parent_->fun_, *iters...);
                });
            }

constexpr auto operator++() -> iterator& {
                ++inner_;
                return *this;
            }
            constexpr auto operator++(int) -> iterator {
                auto tmp = *this;
                ++*this;
                return tmp;
            }

constexpr auto operator+=(difference_type x) -> iterator& requires random_access_range<Base> {
 inner_ += x;
 return *this;
 }
 constexpr auto operator-=(difference_type x) -> iterator& requires random_access_range<Base> {
 inner_ -= x;
 return *this;
 }
 constexpr auto operator[](difference_type n) const -> reference requires random_access_range<Base> {
 return inner_.current_.apply([&](auto const&... iters) -> decltype(auto) {
 return std::invoke(*parent_->fun_, iters[n]...);
 });
 }

constexpr auto operator==(iterator const& rhs) const -> bool {
 return inner_ == rhs.inner_;
 }
 constexpr auto operator<=>(iterator const& rhs) const requires random_access_range<Base> and three_way_comparable<inner_iterator<Const>> {
 return inner_ <=> rhs.inner_;
 }

friend constexpr auto operator+(iterator const& i, difference_type n) -> iterator requires random_access_range<Base> {
 return iterator(*i.parent_, i.inner_ + n);
 }
 friend constexpr auto operator+(difference_type n, iterator const& i) -> iterator requires random_access_range<Base> {
 return iterator(*i.parent_, i.inner_ + n);
 }
 friend constexpr auto operator-(iterator const& x, difference_type y) -> iterator requires random_access_range<Base> {
 return iterator(*x.parent_, x.inner_ - y);
 }
 friend constexpr auto operator-(iterator const& x, iterator const& y) -> difference_type requires random_access_range<Base> {
 return x.inner_ - y.inner_;
 }
 };

template <bool Const>
 class sentinel {
 friend adjacent_transform_view;
 inner_sentinel<Const> inner_ = inner_sentinel<Const>();
 constexpr explicit sentinel(inner_sentinel<Const> inner) : inner_(std::move(inner)) { }
 public:
 sentinel() = default;
 constexpr sentinel(sentinel<not Const> i) requires Const and convertible_to<inner_sentinel<false>, inner_sentinel<Const>>
 : inner_(std::move(i.inner_))
 { }

template <bool OtherConst>
 requires sentinel_for<inner_sentinel<Const>, inner_iterator<OtherConst>>
 constexpr auto operator==(iterator<OtherConst> const& x) const -> bool {
 return x.inner_ == inner_;
 }

template <bool OtherConst>
 requires sized_sentinel_for<inner_sentinel<Const>, inner_iterator<OtherConst>>
 friend constexpr auto operator-(iterator<OtherConst> const& x, sentinel const& y) -> range_difference_t<maybe_const<OtherConst, InnerView>> {
 return x.inner_ - y.inner_;
 }

template <bool OtherConst>
 requires sized_sentinel_for<inner_sentinel<Const>, inner_iterator<OtherConst>>
 friend constexpr auto operator-(sentinel const& x, iterator<OtherConst> const& y) -> range_difference_t<maybe_const<OtherConst, InnerView>> {
 return x.inner_ - y.inner_;
 }
 };
 public:
 constexpr adjacent_transform_view() = default;

constexpr  explicit adjacent_transform_view(V base, F fun)
            : fun_(std::move(fun))
            , inner_(std::move(base))
        { }

constexpr auto begin() -> iterator<false> {
 return iterator<false>(*this, inner_.begin());
 }
 constexpr auto begin() const -> iterator<true>
 requires range<InnerView const>
 and regular_invocable<F const&, range_reference_t<RepeatV const>...>
 {
 return iterator<true>(*this, inner_.begin());
 }

constexpr auto end() -> sentinel<false> {
 return sentinel<false>(inner_.end());
 }
 constexpr auto end() -> iterator<false> requires common_range<InnerView> {
 return iterator<false>(*this, inner_.end());
 }
 constexpr auto end() const -> sentinel<true>
 requires range<InnerView const>
 and regular_invocable<F const&, range_reference_t<RepeatV const>...>
 {
 return sentinel<true>(inner_.end());
 }
 constexpr auto end() const -> iterator<true>
 requires common_range<InnerView const>
 and regular_invocable<F const&, range_reference_t<RepeatV const>...>
 {
 return iterator<true>(*this, inner_.end());
 }

constexpr auto size() requires sized_range<InnerView> {
 return inner_.size();
 }
 constexpr auto size() const requires sized_range<InnerView const> {
 return inner_.size();
 }
 };

namespace views {
 template <size_t N>
 inline constexpr __adaptor::_RangeAdaptor adjacent_transform =
 []<typename F, viewable_range R, copy_constructible FD = decay_t<F>>
 (R&& r, F&& f){
 if constexpr (N == 0) {
 return views::zip_transform(FWD(f));
 } else {
 return adjacent_transform_view<views::all_t<R>, FD, N>(FWD(r), FWD(f));
 }
 };

inline constexpr auto pairwise_transform = adjacent_transform<2>;
 }
}