#pragma once
#include "../tuple_push_pop/lib.hpp"
namespace tifa_libs {
namespace tuple_op_impl_ {
template <class Tpl, class Op2, usz... Is>
CEXP auto apply2_impl_(Op2 f, Tpl&& l, Tpl&& r, std::index_sequence<Is...>) NE { return std::make_tuple(f(std::get<Is>(l), std::get<Is>(r))...); }
} // namespace tuple_op_impl_
template <class Tpl, class Op2>
CEXP auto tuple_apply2(Op2&& f, Tpl&& l, Tpl&& r) NE { return tuple_op_impl_::apply2_impl_(std::forward<Op2>(f), l, r, std::make_index_sequence<tifa_libs::tuple_size<Tpl>>()); }
#define OO_PTEQ_(op) \
template <class... Ts> \
CEXP auto operator op(std::tuple<Ts...> CR l, std::tuple<Ts...> CR r) NE { \
return tuple_apply2([](auto&& l, auto&& r) NE { return l op r; }, l, r); \
} \
template <class... Ts> \
CEXP auto operator op## = (std::tuple<Ts...> & l, std::tuple<Ts...> CR r) NE { return l = l op r; }
OO_PTEQ_(+)
OO_PTEQ_(-)
OO_PTEQ_(*)
OO_PTEQ_(/)
OO_PTEQ_(%)
OO_PTEQ_(&)
OO_PTEQ_(|)
OO_PTEQ_(^)
OO_PTEQ_(<<)
OO_PTEQ_(>>)
#undef OO_PTEQ_
} // namespace tifa_libs
#line 2 "src/util/op/tuple/lib.hpp"
#line 2 "src/util/op/tuple_push_pop/lib.hpp"
#line 2 "src/util/alias/num/lib.hpp"
#line 2 "src/util/util/lib.hpp"
// https://github.com/Tiphereth-A/CP-lib
#include <bits/extc++.h>
// clang-format off
namespace tifa_libs {
#define CEXP constexpr
#define CEXPE constexpr explicit
#define CR const&
#define CP const*
#define PC *const
#define CPC const*const
#define TPN typename
#define NE noexcept
#define CNE const noexcept
#define ND [[nodiscard]]
#define cT_(...) std::conditional_t<sizeof(__VA_ARGS__) <= sizeof(size_t) * 2, __VA_ARGS__, __VA_ARGS__ CR>
// NOLINTNEXTLINE(misc-const-correctness)
#define flt_(T, i, l, r, ...) for (T i = (l), i##e = (r)__VA_OPT__(, ) __VA_ARGS__; i < i##e; ++i)
#define retif_(cond, if_true, ...) if cond return if_true __VA_OPT__(; else return __VA_ARGS__)
#ifdef ONLINE_JUDGE
#undef assert
#define assert(x) 42
#endif
using namespace std::ranges;
using namespace std::literals;
template <class T>
CEXP T abs(T x) NE { retif_((x < 0), -x, x); }
} // namespace tifa_libs
// clang-format on
#line 4 "src/util/alias/num/lib.hpp"
// clang-format off
namespace tifa_libs {
#define mk0_(w, t) using w = t; using c##w = const t
#define mk_(w, t) mk0_(w, t); CEXP w operator""_##w(unsigned long long x) NE { return (w)x; }
mk_(i8, int8_t) mk_(u8, uint8_t) mk_(i16, int16_t) mk_(u16, uint16_t) mk_(i32, int32_t) mk_(u32, uint32_t) mk_(i64, int64_t) mk_(u64, uint64_t) mk_(isz, ssize_t) mk_(usz, size_t) mk_(chr, char) mk_(schr, signed char) mk_(uchr, unsigned char) mk_(sint, signed) mk_(uint, unsigned);
mk0_(i128, __int128_t); mk0_(u128, __uint128_t); mk0_(f32, float); mk0_(f64, double); mk0_(f128, long double);
#undef mk0_
#undef mk_
} // namespace tifa_libs
// clang-format on
#line 4 "src/util/op/tuple_push_pop/lib.hpp"
namespace tifa_libs {
namespace tuple_push_pop_impl_ {
template <usz bgn, class Tpl, usz... Is>
CEXP auto subtuple_impl_(Tpl&& t, std::index_sequence<Is...>) NE { return std::make_tuple(std::get<Is + bgn>(t)...); }
} // namespace tuple_push_pop_impl_
template <class Tpl>
CEXP usz tuple_size = std::tuple_size_v<std::remove_cvref_t<Tpl>>;
template <usz bgn, usz len, class Tpl>
CEXP auto subtuple(Tpl&& t) NE {
static_assert(bgn <= tuple_size<Tpl> && len <= tuple_size<Tpl> && bgn + len <= tuple_size<Tpl>, "Out of range");
return tuple_push_pop_impl_::subtuple_impl_<bgn>(t, std::make_index_sequence<len>());
}
template <usz pos, class T, class Tpl>
CEXP auto tuple_push(T&& v, Tpl&& t) NE {
static_assert(tuple_size<Tpl> > 0, "Pop from empty tuple");
return std::tuple_cat(subtuple<0, pos>(t), std::make_tuple(v), subtuple<pos, tuple_size<Tpl> - pos>(t));
}
template <class T, class Tpl>
CEXP auto tuple_push_front(T&& v, Tpl&& t) NE { return tuple_push<0>(v, t); }
template <class T, class Tpl>
CEXP auto tuple_push_back(T&& v, Tpl&& t) NE { return tuple_push<tuple_size<Tpl>>(v, t); }
template <usz pos, class Tpl>
CEXP auto tuple_pop(Tpl&& t) NE {
static_assert(tuple_size<Tpl> > 0, "Pop from empty tuple");
return std::tuple_cat(subtuple<0, pos>(t), subtuple<pos + 1, tuple_size<Tpl> - pos - 1>(t));
}
template <class Tpl>
CEXP auto tuple_pop_front(Tpl&& t) NE { return tuple_pop<0>(t); }
template <class Tpl>
CEXP auto tuple_pop_back(Tpl&& t) NE { return tuple_pop<tuple_size<Tpl> - 1>(t); }
} // namespace tifa_libs
#line 4 "src/util/op/tuple/lib.hpp"
namespace tifa_libs {
namespace tuple_op_impl_ {
template <class Tpl, class Op2, usz... Is>
CEXP auto apply2_impl_(Op2 f, Tpl&& l, Tpl&& r, std::index_sequence<Is...>) NE { return std::make_tuple(f(std::get<Is>(l), std::get<Is>(r))...); }
} // namespace tuple_op_impl_
template <class Tpl, class Op2>
CEXP auto tuple_apply2(Op2&& f, Tpl&& l, Tpl&& r) NE { return tuple_op_impl_::apply2_impl_(std::forward<Op2>(f), l, r, std::make_index_sequence<tifa_libs::tuple_size<Tpl>>()); }
#define OO_PTEQ_(op) \
template <class... Ts> \
CEXP auto operator op(std::tuple<Ts...> CR l, std::tuple<Ts...> CR r) NE { \
return tuple_apply2([](auto&& l, auto&& r) NE { return l op r; }, l, r); \
} \
template <class... Ts> \
CEXP auto operator op## = (std::tuple<Ts...> & l, std::tuple<Ts...> CR r) NE { return l = l op r; }
OO_PTEQ_(+)
OO_PTEQ_(-)
OO_PTEQ_(*)
OO_PTEQ_(/)
OO_PTEQ_(%)
OO_PTEQ_(&)
OO_PTEQ_(|)
OO_PTEQ_(^)
OO_PTEQ_(<<)
OO_PTEQ_(>>)
#undef OO_PTEQ_
} // namespace tifa_libs
src/util/op/tuple/lib.hpp
src/util/alias/num/lib.hpp