CP-Algorithms Library
This documentation is automatically generated by competitive-verifier/competitive-verifier
tests/multivar.cpp
- View this file on GitHub
- Last update: 2026-09-10 02:45:56+02:00
Depends on
cp-algo/math/common.hpp- cp-algo/math/cvector.hpp
- cp-algo/math/dft.hpp
- cp-algo/math/fft.hpp
- cp-algo/math/multivar.hpp
- cp-algo/math/subset_convolution.hpp
- cp-algo/number_theory/modint.hpp
- cp-algo/random/rng.hpp
- cp-algo/util/big_alloc.hpp
- cp-algo/util/bit.hpp
- cp-algo/util/checkpoint.hpp
- cp-algo/util/complex.hpp
- cp-algo/util/simd.hpp
Code
#include "cp-algo/math/multivar.hpp"
#include <random>
#include <iostream>
using namespace cp_algo;
using namespace cp_algo::math;
template<typename T>
big_vector<T> naive(big_vector<size_t> const& dims, big_vector<T> const& a, big_vector<T> const& b) {
big_vector<T> result(a.size());
for(size_t i = 0; i < a.size(); i++) {
for(size_t j = 0; i + j < a.size(); j++) {
size_t x = i, y = j;
bool carry = false;
for(auto n: dims) {
carry |= x % n + y % n >= n;
x /= n; y /= n;
}
if(!carry) {result[i+j] += a[i] * b[j];}
}
}
return result;
}
template<typename T> void check() {
std::mt19937 rng(59321);
std::vector<big_vector<size_t>> shapes{{}, {1}, {2}, {3}, {4}, {1, 2, 1, 3},
{2, 2, 2, 2, 2, 2}, {2, 2, 2, 2, 2, 2, 2}, {3, 3, 3, 3},
{3, 2, 3, 2, 3}, {2, 3, 2, 3, 2}, {5, 7}, {4, 3, 2}, {31, 3}, {65, 2}};
for(int rep = 0; rep < 80; rep++) {
big_vector<size_t> dims(rng() % 7);
for(auto &n: dims) {n = 1 + rng() % 3;}
shapes.push_back(dims);
}
for(auto const& dims: shapes) {
fft::multivar<T> a(dims), b(dims);
for(auto &x: a.data) {x = rng() % T::mod();}
for(auto &x: b.data) {x = rng() % T::mod();}
auto original = a.data, rhs = b.data;
auto want = naive(dims, original, rhs);
a.mul(b);
assert(a.data == want && b.data == rhs && a.dim == dims);
a.data = original;
want = naive(dims, original, original);
a.mul(a);
assert(a.data == want);
for(auto &x: a.data) {x = T::mod()-1;}
b.data = a.data;
want = naive(dims, a.data, b.data);
a.mul(b);
assert(a.data == want);
}
// Both mutable and const spans remain usable without an explicit template argument.
big_vector<T> a{1, 2, 3, 4}, b{5, 6, 7, 8};
auto x = subset_convolution(std::span(a), std::span(b));
auto y = subset_convolution(std::span<T const>(a), std::span<T const>(b));
assert(x == y && x == naive(big_vector<size_t>{2, 2}, a, b));
// Exercise the rank cap and the largest supported ternary expansion with a closed-form oracle.
std::vector<big_vector<size_t>> large{big_vector<size_t>(9, 2)};
if(max_logn == 20) {
large.push_back(big_vector<size_t>(20, 2));
large.push_back({3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3});
}
for(auto const& dims: large) {
fft::multivar<T> f(dims);
std::ranges::fill(f.data, T::mod()-1);
f.mul(f);
for(size_t i = 0; i < f.N; i++) {
size_t j = i;
T want = 1;
for(auto n: dims) {want *= T(j % n + 1); j /= n;}
assert(f.data[i] == want);
}
}
}
int main() {
check<modint<998244353>>();
check<modint<1000000007>>();
dynamic_modint<>::with_mod(998244353, [] {check<dynamic_modint<>>();});
std::cout << "Multivariate products, squares, unit axes and const inputs passed under two primes and dynamic modint\n";
}
#line 1 "cp-algo/math/multivar.hpp"
#line 1 "cp-algo/util/big_alloc.hpp"
#include <set>
#include <map>
#include <deque>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <cstddef>
#include <iostream>
#include <forward_list>
// Single macro to detect POSIX platforms (Linux, Unix, macOS)
#if defined(__linux__) || defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
# define CP_ALGO_USE_MMAP 1
# include <sys/mman.h>
#else
# define CP_ALGO_USE_MMAP 0
#endif
namespace cp_algo {
template <typename T, size_t Align = 32>
class big_alloc {
static_assert( Align >= alignof(void*), "Align must be at least pointer-size");
static_assert(std::popcount(Align) == 1, "Align must be a power of two");
public:
using value_type = T;
template <class U> struct rebind { using other = big_alloc<U, Align>; };
constexpr bool operator==(const big_alloc&) const = default;
constexpr bool operator!=(const big_alloc&) const = default;
big_alloc() noexcept = default;
template <typename U, std::size_t A>
big_alloc(const big_alloc<U, A>&) noexcept {}
[[nodiscard]] T* allocate(std::size_t n) {
std::size_t padded = round_up(n * sizeof(T));
std::size_t align = std::max<std::size_t>(alignof(T), Align);
#if CP_ALGO_USE_MMAP
if (padded >= MEGABYTE) {
void* raw = mmap(nullptr, padded,
PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
madvise(raw, padded, MADV_HUGEPAGE);
return static_cast<T*>(raw);
}
#endif
return static_cast<T*>(::operator new(padded, std::align_val_t(align)));
}
void deallocate(T* p, std::size_t n) noexcept {
if (!p) return;
std::size_t padded = round_up(n * sizeof(T));
std::size_t align = std::max<std::size_t>(alignof(T), Align);
#if CP_ALGO_USE_MMAP
if (padded >= MEGABYTE) { munmap(p, padded); return; }
#endif
::operator delete(p, padded, std::align_val_t(align));
}
private:
static constexpr std::size_t MEGABYTE = 1 << 20;
static constexpr std::size_t round_up(std::size_t x) noexcept {
return (x + Align - 1) / Align * Align;
}
};
template<typename T> using big_vector = std::vector<T, big_alloc<T>>;
template<typename T> using big_basic_string = std::basic_string<T, std::char_traits<T>, big_alloc<T>>;
template<typename T> using big_deque = std::deque<T, big_alloc<T>>;
template<typename T> using big_stack = std::stack<T, big_deque<T>>;
template<typename T> using big_queue = std::queue<T, big_deque<T>>;
template<typename T> using big_priority_queue = std::priority_queue<T, big_vector<T>>;
template<typename T> using big_forward_list = std::forward_list<T, big_alloc<T>>;
using big_string = big_basic_string<char>;
template<typename Key, typename Value, typename Compare = std::less<Key>>
using big_map = std::map<Key, Value, Compare, big_alloc<std::pair<const Key, Value>>>;
template<typename T, typename Compare = std::less<T>>
using big_multiset = std::multiset<T, Compare, big_alloc<T>>;
template<typename T, typename Compare = std::less<T>>
using big_set = std::set<T, Compare, big_alloc<T>>;
}
#line 1 "cp-algo/number_theory/modint.hpp"
#line 1 "cp-algo/math/common.hpp"
#include <functional>
#include <cstdint>
#include <cassert>
#include <bit>
#line 8 "cp-algo/math/common.hpp"
#include <algorithm>
namespace cp_algo::math {
#ifdef CP_ALGO_MAXN
const int maxn = CP_ALGO_MAXN;
#else
const int maxn = 1 << 19;
#endif
const int magic = 64; // threshold for sizes to run the naive algo
// Nonnegative 64-bit exponents, with an associative operation and its identity.
// Windows >1 precompute odd powers only when that saves operations.
template<int window = 1>
auto bpow(auto const& x, auto n, auto const& one, auto op) {
static_assert(window >= 1 && window <= 6);
if constexpr(window > 1) {
if(n == 0) {return one;}
int bits = std::bit_width(uint64_t(n));
auto low_bit = [&](int high) {
int low = std::max(0, high - window + 1);
while(!((n >> low) & 1)) {low++;}
return low;
};
int first = low_bit(bits - 1);
int cost = (1 << (window - 1)) + first;
for(int j = first - 1; j >= 0;) {
if(!((n >> j) & 1)) {j--;}
else {cost++; j = low_bit(j) - 1;}
}
// Do not pay for the table when binary powering uses fewer operations.
if(cost >= bits + std::popcount(uint64_t(n)) - 2) {return bpow<1>(x, n, one, op);}
using T = std::decay_t<decltype(x)>;
std::vector<T> odd;
odd.reserve(1 << (window - 1));
odd.push_back(x);
auto square = op(x, x);
while(odd.size() < size_t(1 << (window - 1))) {odd.push_back(op(odd.back(), square));}
auto ans = odd[(n >> first) / 2];
for(int j = first - 1; j >= 0;) {
if(!((n >> j) & 1)) {ans = op(ans, ans); j--;}
else {
int low = low_bit(j), length = j - low + 1;
auto digit = (n >> low) & ((1u << length) - 1);
for(int i = 0; i < length; i++) {ans = op(ans, ans);}
ans = op(ans, odd[digit / 2]);
j = low - 1;
}
}
return ans;
} else {
if (n == 0) {
return one;
}
auto ans = x;
for(int j = std::bit_width<uint64_t>(n) - 2; ~j; j--) {
ans = op(ans, ans);
if((n >> j) & 1) {
ans = op(ans, x);
}
}
return ans;
}
}
template<int window = 1>
auto bpow(auto x, auto n, auto ans) {
return bpow<window>(x, n, ans, std::multiplies{});
}
template<typename T>
T bpow(T const& x, auto n) {
return bpow(x, n, T(1));
}
inline constexpr auto inv2(auto x) {
assert(x % 2);
std::make_unsigned_t<decltype(x)> y = 1;
while(y * x != 1) {
y *= 2 - x * y;
}
return y;
}
}
#line 6 "cp-algo/number_theory/modint.hpp"
namespace cp_algo::math {
template<typename modint, typename _Int>
struct modint_base {
using Int = _Int;
using UInt = std::make_unsigned_t<Int>;
static constexpr size_t bits = sizeof(Int) * 8;
using Int2 = std::conditional_t<bits <= 32, int64_t, __int128_t>;
using UInt2 = std::conditional_t<bits <= 32, uint64_t, __uint128_t>;
constexpr static Int mod() {
return modint::mod();
}
constexpr static Int remod() {
return modint::remod();
}
constexpr static UInt2 modmod() {
return UInt2(mod()) * mod();
}
constexpr modint_base() = default;
constexpr modint_base(Int2 rr) {
to_modint().setr(UInt((rr + modmod()) % mod()));
}
constexpr modint inv() const {
return bpow(to_modint(), mod() - 2);
}
modint operator - () const {
modint neg;
neg.r = std::min(-r, remod() - r);
return neg;
}
modint& operator /= (const modint &t) {
return to_modint() *= t.inv();
}
modint& operator *= (const modint &t) {
r = UInt(UInt2(r) * t.r % mod());
return to_modint();
}
modint& operator += (const modint &t) {
r += t.r; r = std::min(r, r - remod());
return to_modint();
}
modint& operator -= (const modint &t) {
r -= t.r; r = std::min(r, r + remod());
return to_modint();
}
modint operator + (const modint &t) const {return modint(to_modint()) += t;}
modint operator - (const modint &t) const {return modint(to_modint()) -= t;}
modint operator * (const modint &t) const {return modint(to_modint()) *= t;}
modint operator / (const modint &t) const {return modint(to_modint()) /= t;}
// Why <=> doesn't work?..
auto operator == (const modint &t) const {return to_modint().getr() == t.getr();}
auto operator != (const modint &t) const {return to_modint().getr() != t.getr();}
auto operator <= (const modint &t) const {return to_modint().getr() <= t.getr();}
auto operator >= (const modint &t) const {return to_modint().getr() >= t.getr();}
auto operator < (const modint &t) const {return to_modint().getr() < t.getr();}
auto operator > (const modint &t) const {return to_modint().getr() > t.getr();}
Int rem() const {
UInt R = to_modint().getr();
return R - (R > (UInt)mod() / 2) * mod();
}
constexpr void setr(UInt rr) {
r = rr;
}
constexpr UInt getr() const {
return r;
}
// Only use these if you really know what you're doing!
static uint64_t modmod8() {return uint64_t(8 * modmod());}
void add_unsafe(UInt t) {r += t;}
void pseudonormalize() {r = std::min(r, r - modmod8());}
modint const& normalize() {
if(r >= (UInt)mod()) {
r %= mod();
}
return to_modint();
}
void setr_direct(UInt rr) {r = rr;}
UInt getr_direct() const {return r;}
protected:
UInt r;
private:
constexpr modint& to_modint() {return static_cast<modint&>(*this);}
constexpr modint const& to_modint() const {return static_cast<modint const&>(*this);}
};
template<typename modint>
concept modint_type = std::is_base_of_v<modint_base<modint, typename modint::Int>, modint>;
template<modint_type modint>
decltype(std::cin)& operator >> (decltype(std::cin) &in, modint &x) {
typename modint::UInt r;
auto &res = in >> r;
x.setr(r);
return res;
}
template<modint_type modint>
decltype(std::cout)& operator << (decltype(std::cout) &out, modint const& x) {
return out << x.getr();
}
template<auto m>
struct modint: modint_base<modint<m>, decltype(m)> {
using Base = modint_base<modint<m>, decltype(m)>;
using Base::Base;
static constexpr Base::Int mod() {return m;}
static constexpr Base::UInt remod() {return m;}
auto getr() const {return Base::r;}
};
template<typename Int = int>
struct dynamic_modint: modint_base<dynamic_modint<Int>, Int> {
using Base = modint_base<dynamic_modint<Int>, Int>;
using Base::Base;
static Base::UInt m_reduce(Base::UInt2 ab) {
if(mod() % 2 == 0) [[unlikely]] {
return typename Base::UInt(ab % mod());
} else {
typename Base::UInt2 m = typename Base::UInt(ab) * imod();
return typename Base::UInt((ab + m * mod()) >> Base::bits);
}
}
static Base::UInt m_transform(Base::UInt a) {
if(mod() % 2 == 0) [[unlikely]] {
return a;
} else {
return m_reduce(a * pw128());
}
}
dynamic_modint& operator *= (const dynamic_modint &t) {
Base::r = m_reduce(typename Base::UInt2(Base::r) * t.r);
return *this;
}
void setr(Base::UInt rr) {
Base::r = m_transform(rr);
}
Base::UInt getr() const {
typename Base::UInt res = m_reduce(Base::r);
return std::min(res, res - mod());
}
static Int mod() {return m;}
static Int remod() {return 2 * m;}
static Base::UInt imod() {return im;}
static Base::UInt2 pw128() {return r2;}
static void switch_mod(Int nm) {
m = nm;
im = m % 2 ? inv2(-m) : 0;
r2 = static_cast<Base::UInt>(static_cast<Base::UInt2>(-1) % m + 1);
}
// Wrapper for temp switching
auto static with_mod(Int tmp, auto callback) {
struct scoped {
Int prev = mod();
~scoped() {switch_mod(prev);}
} _;
switch_mod(tmp);
return callback();
}
private:
static thread_local Int m;
static thread_local Base::UInt im, r2;
};
template<typename Int>
Int thread_local dynamic_modint<Int>::m = 1;
template<typename Int>
dynamic_modint<Int>::Base::UInt thread_local dynamic_modint<Int>::im = -1;
template<typename Int>
dynamic_modint<Int>::Base::UInt thread_local dynamic_modint<Int>::r2 = 0;
}
#line 1 "cp-algo/math/fft.hpp"
#line 1 "cp-algo/math/dft.hpp"
#line 1 "cp-algo/util/checkpoint.hpp"
#line 5 "cp-algo/util/checkpoint.hpp"
#include <chrono>
#line 8 "cp-algo/util/checkpoint.hpp"
namespace cp_algo {
#ifdef CP_ALGO_CHECKPOINT
big_map<big_string, double> checkpoints;
double last;
#endif
template<bool final = false>
void checkpoint([[maybe_unused]] auto const& _msg) {
#ifdef CP_ALGO_CHECKPOINT
big_string msg = _msg;
double now = (double)clock() / CLOCKS_PER_SEC;
double delta = now - last;
last = now;
if(msg.size() && !final) {
checkpoints[msg] += delta;
}
if(final) {
for(auto const& [key, value] : checkpoints) {
std::cerr << key << ": " << value * 1000 << " ms\n";
}
std::cerr << "Total: " << now * 1000 << " ms\n";
}
#endif
}
template<bool final = false>
void checkpoint() {
checkpoint<final>("");
}
}
#line 1 "cp-algo/random/rng.hpp"
#line 4 "cp-algo/random/rng.hpp"
#include <random>
namespace cp_algo::random {
std::mt19937_64 gen(
std::chrono::steady_clock::now().time_since_epoch().count()
);
uint64_t rng() {
return gen();
}
}
#line 1 "cp-algo/math/cvector.hpp"
#line 1 "cp-algo/util/simd.hpp"
#include <experimental/simd>
#line 6 "cp-algo/util/simd.hpp"
#include <memory>
#if defined(__x86_64__) && !defined(CP_ALGO_DISABLE_AVX2)
#define CP_ALGO_SIMD_AVX2_TARGET _Pragma("GCC target(\"avx2\")")
#else
#define CP_ALGO_SIMD_AVX2_TARGET
#endif
#define CP_ALGO_SIMD_PRAGMA_PUSH \
_Pragma("GCC push_options") \
CP_ALGO_SIMD_AVX2_TARGET
CP_ALGO_SIMD_PRAGMA_PUSH
namespace cp_algo {
template<typename T, size_t len>
using simd [[gnu::vector_size(len * sizeof(T))]] = T;
using u64x8 = simd<uint64_t, 8>;
using u32x16 = simd<uint32_t, 16>;
using i64x4 = simd<int64_t, 4>;
using u64x4 = simd<uint64_t, 4>;
using u32x8 = simd<uint32_t, 8>;
using u16x16 = simd<uint16_t, 16>;
using i32x4 = simd<int32_t, 4>;
using u32x4 = simd<uint32_t, 4>;
using u16x8 = simd<uint16_t, 8>;
using u16x4 = simd<uint16_t, 4>;
using i16x4 = simd<int16_t, 4>;
using u8x32 = simd<uint8_t, 32>;
using u8x16 = simd<uint8_t, 16>;
using u8x8 = simd<uint8_t, 8>;
using u8x4 = simd<uint8_t, 4>;
using dx4 = simd<double, 4>;
inline dx4 abs(dx4 a) {
return dx4{
std::abs(a[0]),
std::abs(a[1]),
std::abs(a[2]),
std::abs(a[3])
};
}
// https://stackoverflow.com/a/77376595
// works for ints in (-2^51, 2^51)
static constexpr dx4 magic = dx4() + (3ULL << 51);
inline i64x4 lround(dx4 x) {
return i64x4(x + magic) - i64x4(magic);
}
inline dx4 to_double(i64x4 x) {
return dx4(x + i64x4(magic)) - magic;
}
inline dx4 round(dx4 a) {
return dx4{
std::nearbyint(a[0]),
std::nearbyint(a[1]),
std::nearbyint(a[2]),
std::nearbyint(a[3])
};
}
inline u64x4 low32(u64x4 x) {
return x & uint32_t(-1);
}
inline auto swap_bytes(auto x) {
return decltype(x)(__builtin_shufflevector(u32x8(x), u32x8(x), 1, 0, 3, 2, 5, 4, 7, 6));
}
inline u64x4 montgomery_reduce(u64x4 x, uint32_t mod, uint32_t imod) {
#ifdef __AVX2__
auto x_ninv = u64x4(_mm256_mul_epu32(__m256i(x), __m256i() + imod));
x += u64x4(_mm256_mul_epu32(__m256i(x_ninv), __m256i() + mod));
#else
auto x_ninv = u64x4(u32x8(low32(x)) * imod);
x += x_ninv * uint64_t(mod);
#endif
return swap_bytes(x);
}
inline u64x4 montgomery_mul(u64x4 x, u64x4 y, uint32_t mod, uint32_t imod) {
#ifdef __AVX2__
return montgomery_reduce(u64x4(_mm256_mul_epu32(__m256i(x), __m256i(y))), mod, imod);
#else
return montgomery_reduce(x * y, mod, imod);
#endif
}
inline u32x8 montgomery_mul(u32x8 x, u32x8 y, uint32_t mod, uint32_t imod) {
return u32x8(montgomery_mul(u64x4(x), u64x4(y), mod, imod)) |
u32x8(swap_bytes(montgomery_mul(u64x4(swap_bytes(x)), u64x4(swap_bytes(y)), mod, imod)));
}
inline dx4 rotate_right(dx4 x) {
static constexpr u64x4 shuffler = {3, 0, 1, 2};
return __builtin_shuffle(x, shuffler);
}
template<std::size_t Align = 32>
inline bool is_aligned(const auto* p) noexcept {
return (reinterpret_cast<std::uintptr_t>(p) % Align) == 0;
}
template<class Target>
inline Target& vector_cast(auto &&p) {
return *reinterpret_cast<Target*>(std::assume_aligned<alignof(Target)>(&p));
}
}
#pragma GCC pop_options
#line 1 "cp-algo/util/complex.hpp"
#line 4 "cp-algo/util/complex.hpp"
#include <cmath>
#include <type_traits>
#line 7 "cp-algo/util/complex.hpp"
CP_ALGO_SIMD_PRAGMA_PUSH
namespace cp_algo {
// Custom implementation, since std::complex is UB on non-floating types
template<typename T>
struct complex {
using value_type = T;
T x, y;
inline constexpr complex(): x(), y() {}
inline constexpr complex(T const& x): x(x), y() {}
inline constexpr complex(T const& x, T const& y): x(x), y(y) {}
inline complex& operator *= (T const& t) {x *= t; y *= t; return *this;}
inline complex& operator /= (T const& t) {x /= t; y /= t; return *this;}
inline complex operator * (T const& t) const {return complex(*this) *= t;}
inline complex operator / (T const& t) const {return complex(*this) /= t;}
inline complex& operator += (complex const& t) {x += t.x; y += t.y; return *this;}
inline complex& operator -= (complex const& t) {x -= t.x; y -= t.y; return *this;}
inline complex operator * (complex const& t) const {return {x * t.x - y * t.y, x * t.y + y * t.x};}
inline complex operator / (complex const& t) const {return *this * t.conj() / t.norm();}
inline complex operator + (complex const& t) const {return complex(*this) += t;}
inline complex operator - (complex const& t) const {return complex(*this) -= t;}
inline complex& operator *= (complex const& t) {return *this = *this * t;}
inline complex& operator /= (complex const& t) {return *this = *this / t;}
inline complex operator - () const {return {-x, -y};}
inline complex conj() const {return {x, -y};}
inline T norm() const {return x * x + y * y;}
inline T abs() const {return std::sqrt(norm());}
inline T const real() const {return x;}
inline T const imag() const {return y;}
inline T& real() {return x;}
inline T& imag() {return y;}
inline static constexpr complex polar(T r, T theta) {return {T(r * cos(theta)), T(r * sin(theta))};}
inline auto operator <=> (complex const& t) const = default;
};
template<typename T> inline complex<T> conj(complex<T> const& x) {return x.conj();}
template<typename T> inline T norm(complex<T> const& x) {return x.norm();}
template<typename T> inline T abs(complex<T> const& x) {return x.abs();}
template<typename T> inline T& real(complex<T> &x) {return x.real();}
template<typename T> inline T& imag(complex<T> &x) {return x.imag();}
template<typename T> inline T const real(complex<T> const& x) {return x.real();}
template<typename T> inline T const imag(complex<T> const& x) {return x.imag();}
template<typename T>
inline constexpr complex<T> polar(T r, T theta) {
return complex<T>::polar(r, theta);
}
template<typename T>
inline std::ostream& operator << (std::ostream &out, complex<T> const& x) {
return out << x.real() << ' ' << x.imag();
}
}
#pragma GCC pop_options
#line 7 "cp-algo/math/cvector.hpp"
#include <ranges>
#line 9 "cp-algo/math/cvector.hpp"
CP_ALGO_SIMD_PRAGMA_PUSH
namespace stdx = std::experimental;
namespace cp_algo::math::fft {
static constexpr size_t flen = 4;
using ftype = double;
using vftype = dx4;
using point = complex<ftype>;
using vpoint = complex<vftype>;
static constexpr vftype vz = {};
vpoint vi(vpoint const& r) {
return {-imag(r), real(r)};
}
struct cvector {
big_vector<vpoint> r;
cvector(size_t n) {
n = std::max(flen, std::bit_ceil(n));
r.resize(n / flen);
prepare_roots(n / 16);
checkpoint("cvector create");
}
vpoint& at(size_t k) {return r[k / flen];}
vpoint at(size_t k) const {return r[k / flen];}
template<class pt = point>
inline void set(size_t k, pt const& t) {
if constexpr(std::is_same_v<pt, point>) {
real(r[k / flen])[k % flen] = real(t);
imag(r[k / flen])[k % flen] = imag(t);
} else {
at(k) = t;
}
}
template<class pt = point>
inline pt get(size_t k) const {
if constexpr(std::is_same_v<pt, point>) {
return {real(r[k / flen])[k % flen], imag(r[k / flen])[k % flen]};
} else {
return at(k);
}
}
size_t size() const {
return flen * r.size();
}
static constexpr size_t eval_arg(size_t n) {
if(n < pre_evals) {
return eval_args[n];
} else {
return eval_arg(n / 2) | (n & 1) << (std::bit_width(n) - 1);
}
}
static constexpr point eval_point(size_t n) {
if(n % 2) {
return -eval_point(n - 1);
} else if(n % 4) {
return eval_point(n - 2) * point(0, 1);
} else if(n / 4 < pre_evals) {
return evalp[n / 4];
} else if(n / 4 - pre_evals < extra.size()) {
return extra[n / 4 - pre_evals];
} else {
return polar<ftype>(1., std::numbers::pi / (ftype)std::bit_floor(n) * (ftype)eval_arg(n));
}
}
static constexpr std::array<point, 32> roots = []() {
std::array<point, 32> res;
for(size_t i = 2; i < 32; i++) {
res[i] = polar<ftype>(1., std::numbers::pi / (1ull << (i - 2)));
}
return res;
}();
static constexpr point root(size_t n) {
return roots[std::bit_width(n)];
}
template<int step>
static void exec_on_eval(size_t n, size_t k, auto &&callback) {
callback(k, root(4 * step * n) * eval_point(step * k));
}
template<int step>
static void exec_on_evals(size_t n, auto &&callback) {
point factor = root(4 * step * n);
for(size_t i = 0; i < n; i++) {
callback(i, factor * eval_point(step * i));
}
}
static void do_dot_iter(point rt, vpoint& Bv, vpoint const& Av, vpoint& res) {
res += Av * Bv;
real(Bv) = rotate_right(real(Bv));
imag(Bv) = rotate_right(imag(Bv));
auto x = real(Bv)[0], y = imag(Bv)[0];
real(Bv)[0] = x * real(rt) - y * imag(rt);
imag(Bv)[0] = x * imag(rt) + y * real(rt);
}
void dot(cvector const& t) {
size_t n = this->size();
exec_on_evals<1>(n / flen, [&](size_t k, point rt) __attribute__((always_inline)) {
k *= flen;
auto [Ax, Ay] = at(k);
auto Bv = t.at(k);
vpoint res = vz;
for (size_t i = 0; i < flen; i++) {
vpoint Av = vpoint(vz + Ax[i], vz + Ay[i]);
do_dot_iter(rt, Bv, Av, res);
}
set(k, res);
});
checkpoint("dot");
}
// normalize=false leaves the inverse-transform scale for the caller.
template<bool partial = true, bool normalize = true>
void ifft() {
size_t n = size();
if constexpr (!partial) {
prepare_roots(n / 4);
point pi(0, 1);
exec_on_evals<4>(n / 4, [&](size_t k, point rt) __attribute__((always_inline)) {
k *= 4;
point v1 = conj(rt);
point v2 = v1 * v1;
point v3 = v1 * v2;
auto A = get(k);
auto B = get(k + 1);
auto C = get(k + 2);
auto D = get(k + 3);
set(k, (A + B) + (C + D));
set(k + 2, ((A + B) - (C + D)) * v2);
set(k + 1, ((A - B) - pi * (C - D)) * v1);
set(k + 3, ((A - B) + pi * (C - D)) * v3);
});
}
bool parity = std::countr_zero(n) % 2;
if(parity) {
exec_on_evals<2>(n / (2 * flen), [&](size_t k, point rt) __attribute__((always_inline)) {
k *= 2 * flen;
vpoint cvrt = {vz + real(rt), vz - imag(rt)};
auto B = at(k) - at(k + flen);
at(k) += at(k + flen);
at(k + flen) = B * cvrt;
});
}
transform<true>(n, parity);
checkpoint("ifft");
if constexpr(normalize) {
auto scale = vz + ftype(partial ? flen : 1) / ftype(n);
for(size_t k = 0; k < n; k += flen) {
set(k, get<vpoint>(k) * scale);
}
}
}
template<bool partial = true>
void fft() {
size_t n = size();
prepare_roots(n / (partial ? 16 : 4));
bool parity = std::countr_zero(n) % 2;
transform<false>(n, parity);
if(parity) {
exec_on_evals<2>(n / (2 * flen), [&](size_t k, point rt) __attribute__((always_inline)) {
k *= 2 * flen;
vpoint vrt = {vz + real(rt), vz + imag(rt)};
auto t = at(k + flen) * vrt;
at(k + flen) = at(k) - t;
at(k) += t;
});
}
if constexpr (!partial) {
prepare_roots(n / 4);
point pi(0, 1);
exec_on_evals<4>(n / 4, [&](size_t k, point rt) __attribute__((always_inline)) {
k *= 4;
point v1 = rt;
point v2 = v1 * v1;
point v3 = v1 * v2;
auto A = get(k);
auto B = get(k + 1) * v1;
auto C = get(k + 2) * v2;
auto D = get(k + 3) * v3;
set(k, (A + C) + (B + D));
set(k + 1, (A + C) - (B + D));
set(k + 2, (A - C) + pi * (B - D));
set(k + 3, (A - C) - pi * (B - D));
});
}
checkpoint("fft");
}
static constexpr size_t pre_evals = 1 << 16;
static const std::array<size_t, pre_evals> eval_args;
static const std::array<point, pre_evals> evalp;
private:
// Tile two radix-four stages together before descending into each child.
template<bool inverse>
void transform(size_t n, bool parity) {
auto butterfly = [&](size_t offset, size_t length, size_t begin, size_t end) __attribute__((always_inline)) {
size_t i = length / 4;
point rt = root(16 * n / length) * eval_point(4 * offset / length);
vpoint v1 = {vz + real(rt), inverse ? vz - imag(rt) : vz + imag(rt)};
vpoint v2 = v1 * v1, v3 = v1 * v2;
for(size_t j = offset + begin; j < offset + end; j += flen) {
auto A = at(j), B = at(j+i), C = at(j+2*i), D = at(j+3*i);
if constexpr(inverse) {
at(j) = (A+B)+(C+D);
at(j+2*i) = ((A+B)-(C+D))*v2;
at(j+i) = ((A-B)-vi(C-D))*v1;
at(j+3*i) = ((A-B)+vi(C-D))*v3;
} else {
B = B*v1; C = C*v2; D = D*v3;
at(j) = (A+C)+(B+D);
at(j+i) = (A+C)-(B+D);
at(j+2*i) = (A-C)+vi(B-D);
at(j+3*i) = (A-C)-vi(B-D);
}
}
};
auto recurse = [&](auto &&self, size_t offset, size_t length) -> void {
if(length < 4 * flen) {return;}
if(length >= (1 << 15)) {
size_t step = length / 16;
if constexpr(inverse) {
for(size_t t = 0; t < 16; t++) {self(self, offset + t*step, step);}
}
for(size_t j = 0; j < step; j += 256) {
size_t end = std::min(step, j+256);
if constexpr(inverse) {
for(size_t t=0;t<4;t++) {butterfly(offset+t*length/4, length/4, j,end);}
for(size_t t=0;t<4;t++) {butterfly(offset,length,j+t*step,end+t*step);}
} else {
for(size_t t=0;t<4;t++) {butterfly(offset,length,j+t*step,end+t*step);}
for(size_t t=0;t<4;t++) {butterfly(offset+t*length/4,length/4,j,end);}
}
}
if constexpr(!inverse) {
for(size_t t = 0; t < 16; t++) {self(self, offset + t*step, step);}
}
} else {
if constexpr(inverse) {
for(size_t leaf = offset + 3 * flen; leaf < offset + length; leaf += 4 * flen) {
size_t level = std::min<size_t>(std::countr_one(leaf + 3), std::countr_zero(length));
for(size_t lvl = 4 + parity; lvl <= level; lvl += 2) {
size_t len = size_t(1) << lvl;
butterfly(leaf / len * len, len, 0, len / 4);
}
}
} else {
for(size_t leaf = offset; leaf < offset + length; leaf += 4 * flen) {
size_t level = std::min<size_t>(std::countr_zero(n + leaf), std::countr_zero(length));
level -= level % 2 != parity;
for(size_t lvl = level; lvl >= 4; lvl -= 2) {
size_t len = size_t(1) << lvl;
butterfly(leaf / len * len, len, 0, len / 4);
}
}
}
}
};
// Radix two is performed separately at the leaves.
recurse(recurse, 0, n);
}
static big_vector<point> extra;
// Keep the usual table small; cache additional roots for large transforms.
static void prepare_roots(size_t n) {
if(n <= pre_evals + extra.size()) {return;}
size_t old = extra.size();
extra.resize(std::bit_ceil(n) - pre_evals);
for(size_t i = old; i < extra.size(); i++) {
size_t j = 4 * (i + pre_evals);
extra[i] = polar<ftype>(1., std::numbers::pi / (ftype)std::bit_floor(j) * (ftype)eval_arg(j));
}
}
};
big_vector<point> cvector::extra;
const std::array<size_t, cvector::pre_evals> cvector::eval_args = []() {
std::array<size_t, pre_evals> res = {};
for(size_t i = 1; i < pre_evals; i++) {
res[i] = res[i >> 1] | (i & 1) << (std::bit_width(i) - 1);
}
return res;
}();
const std::array<point, cvector::pre_evals> cvector::evalp = []() {
std::array<point, pre_evals> res = {};
res[0] = 1;
for(size_t n = 1; n < pre_evals; n++) {
res[n] = polar<ftype>(1., std::numbers::pi * ftype(eval_args[n]) / ftype(4 * std::bit_floor(n)));
}
return res;
}();
}
#pragma GCC pop_options
#line 9 "cp-algo/math/dft.hpp"
CP_ALGO_SIMD_PRAGMA_PUSH
namespace cp_algo::math::fft {
// Twist coefficients by a random factor, split near sqrt(mod), and pack pairs of halves.
template<modint_type base>
struct dft {
cvector A, B;
static base factor, ifactor;
using Int2 = base::Int2;
static bool _init;
static int split() {
static const int splt = int(std::sqrt(base::mod())) + 1;
return splt;
}
static uint32_t mod, imod;
static void init() {
if(!_init) {
factor = 1 + random::rng() % (base::mod() - 1);
ifactor = base(1) / factor;
mod = base::mod();
imod = -inv2<uint32_t>(base::mod());
_init = true;
}
}
static std::pair<vftype, vftype>
do_split(auto const& a, size_t idx, u64x4 mul) {
if(idx >= std::size(a)) {
return std::pair{vftype(), vftype()};
}
u64x4 au = {
idx < std::size(a) ? a[idx].getr() : 0,
idx + 1 < std::size(a) ? a[idx + 1].getr() : 0,
idx + 2 < std::size(a) ? a[idx + 2].getr() : 0,
idx + 3 < std::size(a) ? a[idx + 3].getr() : 0
};
au = montgomery_mul(au, mul, mod, imod);
au = au >= base::mod() ? au - base::mod() : au;
auto ai = to_double(i64x4(au >= base::mod() / 2 ? au - base::mod() : au));
auto quo = round(ai * (1.0 / split()));
return std::pair{ai - quo * split(), quo};
}
dft(size_t n): A(n), B(n) {init();}
dft(auto const& a, size_t n, bool partial = true): A(0), B(0) {
// Construct split coefficients once instead of zeroing both buffers first.
A.r.clear(); B.r.clear();
size_t blocks = std::max(flen, std::bit_ceil(n)) / flen;
A.r.reserve(blocks); B.r.reserve(blocks);
init();
base b2x32 = bpow(base(2), 32);
u64x4 cur = {
(bpow(factor, 1) * b2x32).getr(),
(bpow(factor, 2) * b2x32).getr(),
(bpow(factor, 3) * b2x32).getr(),
(bpow(factor, 4) * b2x32).getr()
};
u64x4 step4 = u64x4{} + (bpow(factor, 4) * b2x32).getr();
u64x4 stepn = u64x4{} + (bpow(factor, n) * b2x32).getr();
for(size_t i = 0; i < std::min(n, std::size(a)); i += flen) {
auto [rai, qai] = do_split(a, i, cur);
auto [rani, qani] = do_split(a, n + i, montgomery_mul(cur, stepn, mod, imod));
A.r.emplace_back(rai, rani);
B.r.emplace_back(qai, qani);
cur = montgomery_mul(cur, step4, mod, imod);
}
A.r.resize(blocks); B.r.resize(blocks);
checkpoint("dft init");
if(n) {
if(partial) {
A.fft();
B.fft();
} else {
A.template fft<false>();
B.template fft<false>();
}
}
}
// Multiply split evaluations; Cout collects the mixed low/high terms.
template<bool overwrite = true, bool partial = true>
void dot(auto const& C, auto const& D, auto &Aout, auto &Bout, auto &Cout) const {
cvector::exec_on_evals<1>(A.size() / flen, [&](size_t k, point rt) __attribute__((always_inline)) {
k *= flen;
vpoint AC, AD, BC, BD;
AC = AD = BC = BD = vz;
auto Cv = C.at(k), Dv = D.at(k);
if constexpr(partial) {
auto [Ax, Ay] = A.at(k);
auto [Bx, By] = B.at(k);
// Precompute wrapped coefficients, then select each rotation with SIMD shuffles.
vpoint vrt = {vz + real(rt), vz + imag(rt)};
auto Cr = Cv * vrt, Dr = Dv * vrt;
auto iter = [&]<int i>() __attribute__((always_inline)) {
auto wrap = [&](vftype original, vftype rotated) {
if constexpr(i == 0) {return original;}
else {return __builtin_shufflevector(rotated, original, 4 - i, 5 - i, 6 - i, 7 - i);}
};
vpoint Cw = {wrap(real(Cv), real(Cr)), wrap(imag(Cv), imag(Cr))};
vpoint Dw = {wrap(real(Dv), real(Dr)), wrap(imag(Dv), imag(Dr))};
vpoint Av = {vz + Ax[i], vz + Ay[i]}, Bv = {vz + Bx[i], vz + By[i]};
AC += Av * Cw; AD += Av * Dw;
BC += Bv * Cw; BD += Bv * Dw;
};
iter.template operator()<0>();
iter.template operator()<1>();
iter.template operator()<2>();
iter.template operator()<3>();
} else {
AC = A.at(k) * Cv;
AD = A.at(k) * Dv;
BC = B.at(k) * Cv;
BD = B.at(k) * Dv;
}
if constexpr (overwrite) {
Aout.at(k) = AC;
Cout.at(k) = AD + BC;
Bout.at(k) = BD;
} else {
Aout.at(k) += AC;
Cout.at(k) += AD + BC;
Bout.at(k) += BD;
}
});
checkpoint("dot");
}
void dot(auto &&C, auto const& D) {
dot(C, D, A, B, C);
}
static void do_recover_iter(size_t idx, auto A, auto B, auto C, auto mul, uint64_t splitsplit, auto &res) {
auto A0 = lround(A), A1 = lround(C), A2 = lround(B);
// Center signed lifts in the unsigned Montgomery input range [0, mod*2^32).
auto Ai = A0 + A1 * split() + A2 * splitsplit + (uint64_t(base::mod()) << 31);
auto Au = montgomery_reduce(u64x4(Ai), mod, imod);
Au = montgomery_mul(Au, mul, mod, imod);
Au = Au >= base::mod() ? Au - base::mod() : Au;
for(size_t j = 0; j < flen; j++) {
res[idx + j].setr(typename base::UInt(Au[j]));
}
}
// Round the convolutions and undo twisting, optionally including the inverse-FFT scale.
template<bool normalized = true>
void recover_mod(auto &&C, auto &res, size_t k) {
size_t check = (k + flen - 1) / flen * flen;
assert(res.size() >= check);
size_t n = A.size();
auto scale = vz + ftype(flen) / ftype(n);
auto const splitsplit = base(split() * split()).getr();
base b2x32 = bpow(base(2), 32);
base b2x64 = bpow(base(2), 64);
u64x4 cur = {
(bpow(ifactor, 2) * b2x64).getr(),
(bpow(ifactor, 3) * b2x64).getr(),
(bpow(ifactor, 4) * b2x64).getr(),
(bpow(ifactor, 5) * b2x64).getr()
};
u64x4 step4 = u64x4{} + (bpow(ifactor, 4) * b2x32).getr();
u64x4 stepn = u64x4{} + (bpow(ifactor, n) * b2x32).getr();
for(size_t i = 0; i < std::min(n, k); i += flen) {
auto get = [&](auto const& x) {
if constexpr(normalized) {return x.at(i);}
else {return x.at(i) * scale;}
};
auto [Ax, Ay] = get(A);
auto [Bx, By] = get(B);
auto [Cx, Cy] = get(C);
do_recover_iter(i, Ax, Bx, Cx, cur, splitsplit, res);
if(i + n < k) {
do_recover_iter(i + n, Ay, By, Cy, montgomery_mul(cur, stepn, mod, imod), splitsplit, res);
}
cur = montgomery_mul(cur, step4, mod, imod);
}
checkpoint("recover mod");
}
void mul(auto &&C, auto const& D, auto &res, size_t k) {
assert(A.size() == C.size());
size_t n = A.size();
if(!n) {
res = {};
return;
}
dot(C, D);
// Normalize during recovery to avoid another pass over the buffers.
A.template ifft<true, false>();
B.template ifft<true, false>();
C.template ifft<true, false>();
recover_mod<false>(C, res, k);
}
void mul_inplace(auto &&B, auto& res, size_t k) {
mul(B.A, B.B, res, k);
}
void mul(auto const& B, auto& res, size_t k) {
mul(cvector(B.A), B.B, res, k);
}
big_vector<base> operator *= (dft &B) {
big_vector<base> res(2 * A.size());
mul_inplace(B, res, 2 * A.size());
return res;
}
big_vector<base> operator *= (dft const& B) {
big_vector<base> res(2 * A.size());
mul(B, res, 2 * A.size());
return res;
}
auto operator * (dft const& B) const {
return dft(*this) *= B;
}
point operator [](int i) const {return A.get(i);}
};
template<modint_type base> base dft<base>::factor = 1;
template<modint_type base> base dft<base>::ifactor = 1;
template<modint_type base> bool dft<base>::_init = false;
template<modint_type base> uint32_t dft<base>::mod = {};
template<modint_type base> uint32_t dft<base>::imod = {};
}
#pragma GCC pop_options
#line 4 "cp-algo/math/fft.hpp"
CP_ALGO_SIMD_PRAGMA_PUSH
namespace cp_algo::math::fft {
void mul_slow(auto &a, auto const& b, size_t k) {
if(!std::empty(a) && std::data(a) == std::data(b)) {
using base = std::decay_t<decltype(a[0])>;
size_t n = std::min(k, std::size(a)), m = std::min(k, std::size(b));
if(!m) {a.clear(); return;}
a.resize(k);
// Descending output only reads original coefficients at indices <=j.
for(size_t j = k; j-- > 0;) {
base sum = 0;
size_t lo = j >= n ? j + 1 - n : 0, hi = std::min(j + 1, m);
for(size_t i = lo; i < hi; i++) {
if(n == m && i > j - i) {break;}
auto term = a[i] * a[j - i];
sum += n == m && i != j - i ? term + term : term;
}
a[j] = sum;
}
return;
}
if(std::empty(a) || std::empty(b)) {
a.clear();
} else {
size_t n = std::min(k, std::size(a));
size_t m = std::min(k, std::size(b));
a.resize(k);
for(int j = int(k - 1); j >= 0; j--) {
a[j] *= b[0];
for(int i = std::max(j - (int)n, 0) + 1; i < std::min(j + 1, (int)m); i++) {
a[j] += a[j - i] * b[i];
}
}
}
}
size_t com_size(size_t as, size_t bs) {
if(!as || !bs) {
return 0;
}
return std::max(flen, std::bit_ceil(as + bs - 1) / 2);
}
void mul_truncate(auto &a, auto const& b, size_t k) {
using base = std::decay_t<decltype(a[0])>;
if(std::min({k, std::size(a), std::size(b)}) < magic) {
mul_slow(a, b, k);
return;
}
auto n = std::max(flen, std::bit_ceil(
std::min(k, std::size(a)) + std::min(k, std::size(b)) - 1
) / 2);
size_t as = std::min(k, std::size(a)), bs = std::min(k, std::size(b));
size_t tail = as + bs - 1 - n;
// Correct a short wrapped tail instead of doubling the FFT size.
if(tail <= 32 && as <= n && bs <= n) {
std::array<base, 32> high{};
for(size_t i = 0; i < tail; i++) {
for(size_t j = n + i - bs + 1; j < as; j++) {
high[i] += a[j] * b[n + i - j];
}
}
auto A = dft<base>(a | std::views::take(k), n / 2);
if(as == bs && std::data(a) == std::data(b)) {
a.resize((k + flen - 1) / flen * flen);
A.mul(A, a, std::min(k, n));
} else {
auto B = dft<base>(b | std::views::take(k), n / 2);
a.resize((k + flen - 1) / flen * flen);
A.mul_inplace(B, a, std::min(k, n));
}
auto wrap = bpow(dft<base>::factor, n);
for(size_t i = 0; i < tail; i++) {
a[i] += wrap * high[i];
if(n + i < k) {a[n + i] = high[i];}
}
a.resize(k);
return;
}
auto A = dft<base>(a | std::views::take(k), n);
if(as == bs && std::data(a) == std::data(b)) {
a.resize((k + flen - 1) / flen * flen);
A.mul(A, a, k);
} else {
auto B = dft<base>(b | std::views::take(k), n);
a.resize((k + flen - 1) / flen * flen);
A.mul_inplace(B, a, k);
}
a.resize(k);
}
// store mod x^n-k in first half, x^n+k in second half
// inverse reconstructs the halves with k = 1/(2 * forward_k).
template<bool inverse = false>
void mod_split(auto &&x, size_t n, auto k) {
using base = std::decay_t<decltype(k)>;
dft<base>::init();
assert(std::size(x) == 2 * n);
u64x4 cur = u64x4{} + (k * bpow(base(2), 32)).getr();
for(size_t i = 0; i < n; i += flen) {
u64x4 xl = {
x[i].getr(),
x[i + 1].getr(),
x[i + 2].getr(),
x[i + 3].getr()
};
u64x4 xr = {
x[n + i].getr(),
x[n + i + 1].getr(),
x[n + i + 2].getr(),
x[n + i + 3].getr()
};
if constexpr(!inverse) {
xr = montgomery_mul(xr, cur, dft<base>::mod, dft<base>::imod);
xr = xr >= base::mod() ? xr - base::mod() : xr;
}
auto t = xr;
xr = xl - t;
xl += t;
xl = xl >= base::mod() ? xl - base::mod() : xl;
xr = xr >= base::mod() ? xr + base::mod() : xr;
if constexpr(inverse) {
xl = (xl + (xl & 1) * base::mod()) >> 1;
xr = montgomery_mul(xr, cur, dft<base>::mod, dft<base>::imod);
xr = xr >= base::mod() ? xr - base::mod() : xr;
}
for(size_t k = 0; k < flen; k++) {
x[i + k].setr(typename base::UInt(xl[k]));
x[n + i + k].setr(typename base::UInt(xr[k]));
}
}
cp_algo::checkpoint(inverse ? "mod join" : "mod split");
}
// zero_upper skips arithmetic on the known zero padding in the first split.
void cyclic_mul(auto &a, auto &&b, size_t k, bool zero_upper = false) {
assert(std::popcount(k) == 1);
assert(std::size(a) == std::size(b) && std::size(a) == k);
using base = std::decay_t<decltype(a[0])>;
dft<base>::init();
bool square = std::data(a) == std::data(b);
if(k <= (1 << 16)) {
big_vector<base> ap(begin(a), end(a));
if(square) {mul_truncate(ap, ap, 2 * k);}
else {mul_truncate(ap, b, 2 * k);}
mod_split(ap, k, bpow(dft<base>::factor, k));
std::ranges::copy(ap | std::views::take(k), begin(a));
return;
}
k /= 2;
auto factor = bpow(dft<base>::factor, k);
if(zero_upper) {
std::ranges::copy(std::span(a).first(k), begin(a) + k);
if(!square) {std::ranges::copy(std::span(b).first(k), begin(b) + k);}
} else {
mod_split(a, k, factor);
if(!square) {mod_split(b, k, factor);}
}
auto la = std::span(a).first(k);
auto lb = std::span(b).first(k);
auto ra = std::span(a).last(k);
auto rb = std::span(b).last(k);
cyclic_mul(la, lb, k);
auto A = dft<base>(ra, k / 2);
if(square) {A.mul(A, ra, k);}
else {
auto B = dft<base>(rb, k / 2);
A.mul_inplace(B, ra, k);
}
base i2 = base(2).inv();
factor = factor.inv() * i2;
mod_split<true>(a, k, factor);
}
auto make_copy(auto &&x) {
return x;
}
void cyclic_mul(auto &a, auto const& b, size_t k) {
return cyclic_mul(a, make_copy(b), k);
}
namespace impl {
// Overlap-add for a short fixed operand; every block reuses its transform.
void mul_unbalanced(auto &a, auto const& b) {
using base = std::decay_t<decltype(a[0])>;
auto x = std::span<base const>(a), y = std::span<base const>(b);
if(x.size() < y.size()) {std::swap(x, y);}
constexpr size_t length = 1 << 15;
size_t step = length - y.size() + 1;
auto fixed = dft<base>(y, length / 2);
std::decay_t<decltype(a)> result(x.size() + y.size() - 1);
big_vector<base> work(length);
for(size_t start = 0; start < x.size(); start += step) {
size_t count = std::min(step, x.size() - start);
auto block = dft<base>(x.subspan(start, count), length / 2);
size_t need = count + y.size() - 1;
block.mul(fixed, work, need);
for(size_t i = 0; i < need; i++) {result[start + i] += work[i];}
}
a = std::move(result);
}
}
void mul(auto &a, auto &&b) {
if(std::empty(a) || std::empty(b)) {a.clear(); return;}
bool square = std::data(a) == std::data(b) && std::size(a) == std::size(b);
if(!square && std::data(a) == std::data(b)) {
auto copy = make_copy(b);
return mul(a, copy);
}
size_t small = std::min(size(a), size(b)), large = std::max(size(a), size(b));
if(small >= magic && small <= 4096 && large >= (1 << 20) && large / small >= 64) {
return impl::mul_unbalanced(a, b);
}
using base = std::decay_t<decltype(a[0])>;
size_t N = size(a) + size(b);
if(N > (1 << 20)) {
N--;
size_t NN = std::bit_ceil(N);
bool zero_upper = std::max(size(a), size(b)) <= NN / 2;
a.resize(NN);
// Compute the negative branch before the positive branch consumes the inputs.
// Only the result needs the upper half; b never needs duplicated padding.
if(zero_upper && !square) {
size_t half = NN / 2;
b.resize(half);
auto lo = std::span(a).first(half), hi = std::span(a).last(half);
{
auto A = dft<base>(lo, half / 2);
auto B = dft<base>(b, half / 2);
A.mul_inplace(B, hi, half);
}
cyclic_mul(lo, b, half);
mod_split<true>(a, half, (base(2) * bpow(dft<base>::factor, half)).inv());
} else {
if(!square) {b.resize(NN);}
cyclic_mul(a, b, NN, zero_upper);
}
a.resize(N);
} else {
mul_truncate(a, b, N - 1);
}
}
void mul(auto &a, auto const& b) {
if(std::empty(a) || std::empty(b)) {a.clear(); return;}
size_t small = std::min(size(a), size(b)), large = std::max(size(a), size(b));
if(small >= magic && small <= 4096 && large >= (1 << 20) && large / small >= 64) {
return impl::mul_unbalanced(a, b);
}
size_t N = size(a) + size(b);
if(N > (1 << 20)) {
if(std::data(a) == std::data(b) && std::size(a) == std::size(b)) {mul(a, a);}
else {mul(a, make_copy(b));}
} else {
mul_truncate(a, b, N - 1);
}
}
}
#pragma GCC pop_options
#line 1 "cp-algo/math/subset_convolution.hpp"
#line 1 "cp-algo/util/bit.hpp"
#line 6 "cp-algo/util/bit.hpp"
#include <array>
#line 8 "cp-algo/util/bit.hpp"
#if defined(__x86_64__) && !defined(CP_ALGO_DISABLE_AVX2)
#define CP_ALGO_BIT_OPS_TARGET _Pragma("GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")")
#else
#define CP_ALGO_BIT_OPS_TARGET _Pragma("GCC target(\"bmi,bmi2,lzcnt,popcnt\")")
#endif
#define CP_ALGO_BIT_PRAGMA_PUSH \
_Pragma("GCC push_options") \
CP_ALGO_BIT_OPS_TARGET
CP_ALGO_BIT_PRAGMA_PUSH
namespace cp_algo {
template<typename Uint>
constexpr size_t bit_width = sizeof(Uint) * 8;
// n < 64
uint64_t mask(size_t n) {
return (1ULL << n) - 1;
}
size_t order_of_bit(auto x, size_t k) {
return k ? std::popcount(x << (bit_width<decltype(x)> - k)) : 0;
}
inline size_t kth_set_bit(uint64_t x, size_t k) {
return std::countr_zero(_pdep_u64(1ULL << k, x));
}
template<int fl = 0>
void with_bit_floor(size_t n, auto &&callback) {
if constexpr (fl >= 63) {
return;
} else if (n >> (fl + 1)) {
with_bit_floor<fl + 1>(n, callback);
} else {
callback.template operator()<1ULL << fl>();
}
}
void with_bit_ceil(size_t n, auto &&callback) {
with_bit_floor(n, [&]<size_t N>() {
if(N == n) {
callback.template operator()<N>();
} else {
callback.template operator()<N << 1>();
}
});
}
inline uint32_t read_bits(char const* p) {
return _mm256_movemask_epi8(__m256i(vector_cast<u8x32 const>(p[0]) + (127 - '0')));
}
inline uint64_t read_bits64(char const* p) {
return read_bits(p) | (uint64_t(read_bits(p + 32)) << 32);
}
inline void write_bits(char *p, uint32_t bits) {
static constexpr u8x32 shuffler = {
0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2,
3, 3, 3, 3, 3, 3, 3, 3
};
auto shuffled = u8x32(_mm256_shuffle_epi8(__m256i() + bits, __m256i(shuffler)));
static constexpr u8x32 mask = {
1, 2, 4, 8, 16, 32, 64, 128,
1, 2, 4, 8, 16, 32, 64, 128,
1, 2, 4, 8, 16, 32, 64, 128,
1, 2, 4, 8, 16, 32, 64, 128
};
for(int z = 0; z < 32; z++) {
p[z] = shuffled[z] & mask[z] ? '1' : '0';
}
}
inline void write_bits64(char *p, uint64_t bits) {
write_bits(p, uint32_t(bits));
write_bits(p + 32, uint32_t(bits >> 32));
}
}
#pragma GCC pop_options
#line 11 "cp-algo/math/subset_convolution.hpp"
#include <cstring>
CP_ALGO_SIMD_PRAGMA_PUSH
namespace cp_algo::math {
#ifndef CP_ALGO_SUBSET_CONVOLUTION_MAX_LOGN
#define CP_ALGO_SUBSET_CONVOLUTION_MAX_LOGN 20
#endif
const size_t max_logn = CP_ALGO_SUBSET_CONVOLUTION_MAX_LOGN;
template<auto N>
inline void xor_transform(auto &&a) {
if constexpr (N >> max_logn) {
throw std::runtime_error("N too large for xor_transform");
} else if constexpr (N <= 32) {
for (size_t i = 1; i < N; i *= 2) {
for (size_t j = 0; j < N; j += 2 * i) {
for (size_t k = j; k < j + i; k++) {
for (size_t z = 0; z < max_logn; z++) {
auto x = a[k][z] + a[k + i][z];
auto y = a[k][z] - a[k + i][z];
a[k][z] = x;
a[k + i][z] = y;
}
}
}
}
} else {
auto add = [&](auto &a, auto &b) __attribute__((always_inline)) {
auto x = a + b, y = a - b;
a = x, b = y;
};
constexpr auto quar = N / 4;
for (size_t i = 0; i < (size_t)quar; i++) {
auto x0 = a[i + (size_t)quar * 0];
auto x1 = a[i + (size_t)quar * 1];
auto x2 = a[i + (size_t)quar * 2];
auto x3 = a[i + (size_t)quar * 3];
#pragma GCC unroll max_logn
for (size_t z = 0; z < max_logn; z++) {
add(x0[z], x2[z]);
add(x1[z], x3[z]);
}
#pragma GCC unroll max_logn
for (size_t z = 0; z < max_logn; z++) {
add(x0[z], x1[z]);
add(x2[z], x3[z]);
}
a[i + (size_t)quar * 0] = x0;
a[i + (size_t)quar * 1] = x1;
a[i + (size_t)quar * 2] = x2;
a[i + (size_t)quar * 3] = x3;
}
xor_transform<quar>(&a[quar * 0]);
xor_transform<quar>(&a[quar * 1]);
xor_transform<quar>(&a[quar * 2]);
xor_transform<quar>(&a[quar * 3]);
}
}
inline void xor_transform(auto &&a, auto n) {
with_bit_floor(n, [&]<auto NN>() {
assert(NN == n);
xor_transform<NN>(a);
});
}
inline void xor_transform(auto &&a) {
xor_transform(a, std::size(a));
}
// Generic rank vectors processor with variadic inputs
// Assumes output[0] = 0, caller is responsible for handling rank 0
// Returns the output array
auto on_rank_vectors(auto &&cb, auto const& ...inputs) {
static_assert(sizeof...(inputs) >= 1, "on_rank_vectors requires at least one input");
// Create tuple of input references once
auto input_tuple = std::forward_as_tuple(inputs...);
auto const& first_input = std::get<0>(input_tuple);
using base = std::decay_t<decltype(first_input[0])>;
big_vector<base> out(std::size(first_input));
auto N = std::size(first_input);
constexpr size_t K = 4;
N = std::max(N, 2 * K);
const size_t n = std::bit_width(N) - 1;
const size_t T = std::min<size_t>(n - 3, 2);
const size_t bottoms = 1 << (n - T - 1);
const auto M = std::size(first_input);
// Create array buffers for each input
auto create_buffers = [bottoms]<typename... Args>(const Args&...) {
return std::make_tuple(
big_vector<std::array<typename std::decay_t<Args>::value_type, max_logn>>(bottoms)...
);
};
auto buffers = std::apply(create_buffers, input_tuple);
checkpoint("alloc buffers");
big_vector<uint32_t> counts(2 * bottoms);
for(size_t i = 1; i < 2 * bottoms; i++) {
counts[i] = (uint32_t)std::popcount(i);
}
checkpoint("prepare");
for(size_t top = 0; top < N / 2; top += bottoms) {
// Clear all buffers
std::apply([bottoms](auto&... bufs) {
(..., memset(bufs.data(), 0, sizeof(bufs[0]) * bottoms));
}, buffers);
checkpoint("memset");
// Initialize buffers from inputs
std::apply([&](auto const&... inps) {
std::apply([&](auto&... bufs) {
auto init_one = [&](auto const& inp, auto& buf) {
for(size_t i = 0; i < M; i += 2 * bottoms) {
bool parity = __builtin_parity(uint32_t((i >> 1) & top));
size_t limit = std::min(M, i + 2 * bottoms) - i;
uint32_t count = (uint32_t)std::popcount(i) - 1;
for(size_t bottom = (i == 0); bottom < limit; bottom++) {
if (parity) {
buf[bottom >> 1][count + counts[bottom]] -= inp[i + bottom];
} else {
buf[bottom >> 1][count + counts[bottom]] += inp[i + bottom];
}
}
}
};
(init_one(inps, bufs), ...);
}, buffers);
}, input_tuple);
checkpoint("init");
std::apply([](auto&... bufs) {
(..., xor_transform(bufs));
}, buffers);
checkpoint("transform");
assert(bottoms % K == 0);
for(size_t i = 0; i < bottoms; i += K) {
std::apply([&](auto&... bufs) {
auto extract_one = [&](auto& buf) {
std::array<u64x4, max_logn> aa;
for(size_t j = 0; j < max_logn; j++) {
for(size_t z = 0; z < K; z++) {
aa[j][z] = buf[i + z][j].getr();
}
}
return aa;
};
auto aa_tuple = std::make_tuple(extract_one(bufs)...);
std::apply(cb, aa_tuple);
// Write results back: only first array needs to be written
auto& first_buf = std::get<0>(std::forward_as_tuple(bufs...));
const auto& first_aa = std::get<0>(aa_tuple);
for(size_t j = 0; j < max_logn; j++) {
for(size_t z = 0; z < K; z++) {
first_buf[i + z][j].setr((uint32_t)first_aa[j][z]);
}
}
}, buffers);
}
checkpoint("dot");
auto& first_buf = std::get<0>(buffers);
xor_transform(first_buf);
checkpoint("transform");
// Gather results from first buffer
for(size_t i = 0; i < M; i += 2 * bottoms) {
bool parity = __builtin_parity(uint32_t((i >> 1) & top));
size_t limit = std::min(M, i + 2 * bottoms) - i;
uint32_t count = (uint32_t)std::popcount(i) - 1;
for(size_t bottom = (i == 0); bottom < limit; bottom++) {
if (parity) {
out[i + bottom] -= first_buf[bottom >> 1][count + counts[bottom]];
} else {
out[i + bottom] += first_buf[bottom >> 1][count + counts[bottom]];
}
}
}
checkpoint("gather");
}
const base ni = base(N / 2).inv();
for(auto& x : out) {x *= ni;}
return out;
}
template<typename value_type>
big_vector<std::remove_const_t<value_type>> subset_convolution(std::span<value_type> f, std::span<value_type> g) {
using base = std::remove_const_t<value_type>;
big_vector<base> outpa;
const size_t lgn = std::min<size_t>(max_logn, std::bit_width(f.size()) - 1);
outpa = on_rank_vectors([lgn](auto &a, auto const& b) {
std::decay_t<decltype(a)> res = {};
const auto mod = base::mod();
const auto imod = math::inv2(-mod);
const auto r4 = u64x4() + uint64_t(-1) % mod + 1;
auto add = [&](size_t i) {
for(size_t j = 0; i + j + 1 < lgn; j++) {
res[i + j + 1] += (u64x4)_mm256_mul_epu32(__m256i(a[i]), __m256i(b[j]));
}
if (i == 15) {
for(size_t k = 0; k < lgn; k++) {
res[k] -= (res[k] >= base::modmod8()) & base::modmod8();
}
}
};
for(size_t i = 0; i < lgn; i++) { add(i); }
for(size_t k = 0; k < max_logn; k++) {
res[k] = montgomery_reduce(res[k], mod, imod);
res[k] = montgomery_mul(res[k], r4, mod, imod);
a[k] = res[k] >= mod ? res[k] - mod : res[k];
}
}, f, g);
outpa[0] = f[0] * g[0];
for(size_t i = 1; i < std::size(f); i++) {
outpa[i] += f[i] * g[0] + f[0] * g[i];
}
checkpoint("fix 0");
return outpa;
}
template<typename base>
big_vector<base> subset_div(std::span<base> f, std::span<base> g) {
big_vector<base> outpa;
constexpr size_t lgn = max_logn;
auto inv = g[0].inv();
auto f0 = (f[0] * inv).getr(), gi = inv.getr();
const auto mod = base::mod();
const auto imod = math::inv2(-mod);
const auto gir4 = u64x4() + (uint64_t(-1) % mod + 1) * gi % mod;
// Eight products and the subsequent Montgomery reduction fit below 2^64.
const size_t period = mod < (1u << 30) ? 8 : 1;
const uint64_t bound = uint64_t(period * base::modmod());
outpa = on_rank_vectors([=](auto &a, auto const& b) {
for(size_t k = 0; k < lgn; k++) {
for(size_t i = 0; i < k; i++) {
a[k] -= (u64x4)_mm256_mul_epu32(__m256i(a[i]), __m256i(b[k - 1 - i]));
if(i % period == period - 1 || i + 1 == k) {
a[k] = a[k] >= bound ? a[k] + bound : a[k];
}
}
a[k] -= (u64x4)_mm256_mul_epu32(__m256i() + f0, __m256i(b[k]));
a[k] = a[k] >= bound ? a[k] + bound : a[k];
a[k] = montgomery_reduce(a[k], mod, imod);
a[k] = montgomery_mul(a[k], gir4, mod, imod);
a[k] = a[k] >= mod ? a[k] - mod : a[k];
}
}, f, g);
outpa[0] = f0;
checkpoint("fix 0");
return outpa;
}
template<typename base>
big_vector<base> subset_log(std::span<base> g) {
if (size(g) == 1) {
assert(g[0] == base(1));
return big_vector<base>{0};
}
size_t N = std::size(g);
auto out0 = subset_log(std::span(g).first(N / 2));
auto out1 = subset_div<base>(std::span(g).last(N / 2), std::span(g).first(N / 2));
out0.insert(end(out0), begin(out1), end(out1));
cp_algo::checkpoint("extend out");
return out0;
}
template<typename base>
big_vector<base> subset_exp(std::span<base> g) {
if (size(g) == 1) {
assert(g[0] == base(0));
return big_vector<base>{1};
}
size_t N = std::size(g);
auto out0 = subset_exp(std::span(g).first(N / 2));
auto out1 = subset_convolution<base>(out0, std::span(g).last(N / 2));
out0.insert(end(out0), begin(out1), end(out1));
cp_algo::checkpoint("extend out");
return out0;
}
template<typename base>
big_vector<big_vector<base>> subset_compose(std::span<base> f, std::span<base> g, size_t n) {
if (size(g) == 1) {
size_t M = size(f);
big_vector res(n, big_vector<base>{0});
big_vector<base> pw(std::max(n, M) + 1);
pw[0] = 1;
for (size_t j = 1; j < M; j++) {
pw[j] = pw[j - 1] * g[0];
}
for (size_t i = 0; i < n; i++) {
for (size_t j = 0; j < M; j++) {
res[i][0] += pw[j] * f[j];
}
for (size_t j = M; j > i; j--) {
pw[j] = pw[j - 1] * base(j);
}
pw[i] = 0;
}
cp_algo::checkpoint("base case");
return res;
}
size_t N = std::size(g);
auto deeper = subset_compose(f, std::span(g).first(N / 2), n + 1);
for(size_t i = 0; i + 1 < size(deeper); i++) {
auto next = subset_convolution<base>(deeper[i + 1], std::span(g).last(N / 2));
deeper[i].insert(end(deeper[i]), begin(next), end(next));
}
deeper.pop_back();
cp_algo::checkpoint("combine");
return deeper;
}
template<typename base>
big_vector<base> subset_compose(std::span<base> f, std::span<base> g) {
return subset_compose(f, g, 1)[0];
}
// Transpose of f -> f * g = h
template<typename base>
big_vector<base> subset_conv_transpose(std::span<base> h, std::span<base> g) {
std::ranges::reverse(h);
auto res = subset_convolution<base>(h, g);
std::ranges::reverse(h);
std::ranges::reverse(res);
return res;
}
template<typename base>
big_vector<base> subset_power_projection(big_vector<big_vector<base>> &&fg, std::span<base> g, size_t M) {
if (size(g) == 1) {
size_t n = size(fg);
big_vector<base> res(M);
big_vector<base> pw(std::max(n, M) + 1);
pw[0] = 1;
for (size_t j = 1; j < M; j++) {
pw[j] = pw[j - 1] * g[0];
}
for (size_t i = 0; i < size(fg); i++) {
for (size_t j = 0; j < M; j++) {
res[j] += pw[j] * fg[i][0];
}
for (size_t j = M; j > i; j--) {
pw[j] = pw[j - 1] * base(j);
}
pw[i] = 0;
}
cp_algo::checkpoint("base case");
return res;
}
size_t N = std::size(g);
fg.emplace_back(N / 2);
for(auto&& [i, h]: fg | std::views::enumerate | std::views::reverse | std::views::drop(1)) {
auto prev = subset_conv_transpose<base>(std::span(h).last(N / 2), std::span(g).last(N / 2));
for (size_t j = 0; j < N / 2; j++) {
fg[i + 1][j] += prev[j];
}
fg[i + 1].resize(N / 2);
}
fg[0].resize(N / 2);
cp_algo::checkpoint("decombine");
return subset_power_projection(std::move(fg), std::span(g).first(N / 2), M);
}
template<typename base>
big_vector<base> subset_power_projection(std::span<base> g, std::span<base> w, size_t M) {
return subset_power_projection({{begin(w), end(w)}}, g, M);
}
}
#pragma GCC pop_options
#line 7 "cp-algo/math/multivar.hpp"
CP_ALGO_SIMD_PRAGMA_PUSH
namespace cp_algo::math::fft {
template<modint_type base>
struct multivar {
big_vector<base> data;
big_vector<size_t> ranks;
big_vector<size_t> dim;
size_t N;
size_t rank(size_t i) {
size_t cur = 1, res = 0, K = size(dim);
if(K == 0) return 0;
for(auto ni: dim) {
cur *= ni;
res += i / cur;
}
return res % K;
}
static void copy_prefix(
big_vector<base>& dst,
big_vector<size_t> const& dst_dim,
big_vector<base> const& src,
big_vector<size_t> const& src_dim,
big_vector<size_t> const& iter_dim,
size_t iter_N
) {
size_t K = iter_dim.size();
if(K == 0) {
dst[0] = src[0];
return;
}
if(K == 1) {
std::copy_n(src.data(), iter_dim[0], dst.data());
return;
}
if(K == 2) {
size_t rows = iter_dim[1], cols = iter_dim[0];
for(size_t j = 0; j < rows; j++) {
std::copy_n(
src.data() + j * src_dim[0],
cols,
dst.data() + j * dst_dim[0]
);
}
return;
}
big_vector<size_t> src_stride(K), dst_stride(K);
src_stride[0] = 1;
dst_stride[0] = 1;
for(size_t i = 1; i < K; i++) {
src_stride[i] = src_stride[i - 1] * src_dim[i - 1];
dst_stride[i] = dst_stride[i - 1] * dst_dim[i - 1];
}
big_vector<size_t> idx(K);
size_t src_index = 0, dst_index = 0;
for(size_t t = 0; t < iter_N; t++) {
dst[dst_index] = src[src_index];
for(size_t d = 0; d < K; d++) {
idx[d]++;
src_index += src_stride[d];
dst_index += dst_stride[d];
if(idx[d] < iter_dim[d]) {
break;
}
idx[d] = 0;
src_index -= src_stride[d] * iter_dim[d];
dst_index -= dst_stride[d] * iter_dim[d];
}
}
}
multivar(auto const& dim): dim(begin(dim), end(dim)), N(
std::ranges::fold_left(dim, 1, std::multiplies{})
) {
data.resize(N);
ranks.resize(N);
for(auto [i, x]: ranks | std::views::enumerate) {
x = rank(i);
}
checkpoint("multivar init");
}
size_t linear_index(auto const& idx) const {
size_t pos = 0, stride = 1;
size_t K = dim.size();
for(size_t i = 0; i < K; i++) {
pos += idx[i] * stride;
stride *= dim[i];
}
return pos;
}
template<class Idx> requires requires(Idx const& idx) { idx[0]; }
base& operator[](Idx const& idx) {
return data[linear_index(idx)];
}
template<class Idx> requires requires(Idx const& idx) { idx[0]; }
base const& operator[](Idx const& idx) const {
return data[linear_index(idx)];
}
template<std::convertible_to<size_t>... Args>
base& operator[](Args... args) {
size_t idx[] = {static_cast<size_t>(args)...};
return data[linear_index(idx)];
}
template<std::convertible_to<size_t>... Args>
base const& operator[](Args... args) const {
size_t idx[] = {static_cast<size_t>(args)...};
return data[linear_index(idx)];
}
void read() {
for(auto &it: data) {
std::cin >> it;
}
checkpoint("multivar read");
}
void print() {
for(auto &it: data) {
std::cout << it << " ";
}
std::cout << "\n";
checkpoint("multivar write");
}
void assign_prefix_from(multivar<base> const& src) {
assert(dim.size() == src.dim.size());
size_t K = dim.size();
if(K == 0) {
data[0] = src.data[0];
return;
}
for(size_t i = 0; i < K; i++) {
assert(src.dim[i] <= dim[i]);
}
copy_prefix(data, dim, src.data, src.dim, src.dim, src.N);
}
multivar<base> truncated(auto const& new_dim) const {
big_vector<size_t> nd(begin(new_dim), end(new_dim));
assert(nd.size() == dim.size());
for(size_t i = 0; i < nd.size(); i++) {
assert(nd[i] <= dim[i]);
}
multivar<base> out(nd);
if(out.N == 0) {
return out;
}
copy_prefix(out.data, out.dim, data, dim, out.dim, out.N);
return out;
}
void truncate_inplace(auto const& new_dim) {
big_vector<size_t> nd(begin(new_dim), end(new_dim));
assert(nd.size() == dim.size());
size_t K = nd.size();
for(size_t i = 0; i < K; i++) {
assert(nd[i] <= dim[i]);
}
size_t new_N = std::ranges::fold_left(nd, 1, std::multiplies{});
if(new_N == 0) {
data.clear();
dim = std::move(nd);
ranks.clear();
N = 0;
return;
}
// In-place: copy elements forward (src >= dst, so no overlap issues)
if(K == 1) {
// 1D: just resize
} else if(K == 2) {
size_t rows = nd[1], cols = nd[0];
for(size_t j = 1; j < rows; j++) {
std::copy_n(
data.data() + j * dim[0],
cols,
data.data() + j * cols
);
}
} else {
copy_prefix(data, nd, data, dim, nd, new_N);
}
data.resize(new_N);
dim = std::move(nd);
N = new_N;
ranks.resize(N);
for(auto [i, x]: ranks | std::views::enumerate) {
x = rank(i);
}
}
void mul(multivar<base> const& b) {
assert(dim == b.dim);
size_t K = size(dim);
if(K == 0) {
data[0] *= b.data[0];
return;
}
if(mul_subset(b)) {return;}
big_vector<dft<base>> A, B;
size_t M = std::max(flen, std::bit_ceil(2 * N - 1) / 2);
for(size_t i = 0; i < K; i++) {
A.emplace_back(data | std::views::enumerate | std::views::transform(
[&](auto jx) {
auto [j, x] = jx;
return ranks[j] == i ? x : base(0);
}
), M, false);
B.emplace_back(b.data | std::views::enumerate | std::views::transform(
[&](auto jx) {
auto [j, x] = jx;
return ranks[j] == i ? x : base(0);
}
), M, false);
}
for(size_t i = 0; i < K; i++) {
dft<base> C(M);
cvector X = C.A;
for(size_t j = 0; j < K; j++) {
size_t tj = (i - j + K) % K;
A[j].template dot<false, false>(B[tj].A, B[tj].B, C.A, C.B, X);
}
checkpoint("dot");
big_vector<base> res((N + flen - 1) / flen * flen);
C.A.template ifft<false>();
C.B.template ifft<false>();
X.template ifft<false>();
C.recover_mod(X, res, N);
for(size_t j = 0; j < N; j++) {
if(i == ranks[j]) {
data[j] = res[j];
}
}
checkpoint("store");
}
}
private:
bool mul_subset(multivar const& b) {
// The SIMD subset product accumulates at most 20 ranks in 64-bit lanes.
if constexpr(base::bits > 32 || max_logn < 3 || max_logn > 20) {return false;}
if(N < 64 || base::mod() % 2 == 0 || base::mod() >= (1 << 30)) {return false;}
size_t bits = 0, threes = 0;
for(auto n: dim) {
if(n < 1 || n > 3) {return false;}
bits += n - 1;
threes += n == 3;
}
if(bits > max_logn || threes > 7) {return false;}
if(!threes) {
data = subset_convolution<base const>(data, b.data);
return true;
}
// Embed x^3=0 via x=u+v, u^2=v^2=0: x^2 maps to 2uv.
// Each ternary axis expands 3 coefficients to 4; cap total expansion at (4/3)^7.
size_t M = size_t(1) << bits;
big_vector<size_t> index(M);
big_vector<uint8_t> degree(M);
size_t block = 1, stride = 1;
for(auto n: dim) {
for(size_t mask = 1; mask < (size_t(1) << (n - 1)); mask++) {
size_t rank = std::popcount(mask);
for(size_t j = 0; j < block; j++) {
index[mask * block + j] = index[j] + rank * stride;
degree[mask * block + j] = degree[j] + (rank == 2);
}
}
block <<= n - 1;
stride *= n;
}
std::array<base, 8> weight, iweight;
weight[0] = iweight[0] = 1;
base half = base(2).inv();
for(size_t i = 1; i <= threes; i++) {
weight[i] = weight[i-1] * base(2);
iweight[i] = iweight[i-1] * half;
}
big_vector<base> f(M), g(M);
for(size_t i = 0; i < M; i++) {
f[i] = data[index[i]] * weight[degree[i]];
g[i] = b.data[index[i]] * weight[degree[i]];
}
auto h = subset_convolution<base>(f, g);
// Equivalent Boolean representatives agree, so repeated stores are harmless.
for(size_t i = 0; i < M; i++) {data[index[i]] = h[i] * iweight[degree[i]];}
return true;
}
};
}
#pragma GCC pop_options
#line 4 "tests/multivar.cpp"
using namespace cp_algo;
using namespace cp_algo::math;
template<typename T>
big_vector<T> naive(big_vector<size_t> const& dims, big_vector<T> const& a, big_vector<T> const& b) {
big_vector<T> result(a.size());
for(size_t i = 0; i < a.size(); i++) {
for(size_t j = 0; i + j < a.size(); j++) {
size_t x = i, y = j;
bool carry = false;
for(auto n: dims) {
carry |= x % n + y % n >= n;
x /= n; y /= n;
}
if(!carry) {result[i+j] += a[i] * b[j];}
}
}
return result;
}
template<typename T> void check() {
std::mt19937 rng(59321);
std::vector<big_vector<size_t>> shapes{{}, {1}, {2}, {3}, {4}, {1, 2, 1, 3},
{2, 2, 2, 2, 2, 2}, {2, 2, 2, 2, 2, 2, 2}, {3, 3, 3, 3},
{3, 2, 3, 2, 3}, {2, 3, 2, 3, 2}, {5, 7}, {4, 3, 2}, {31, 3}, {65, 2}};
for(int rep = 0; rep < 80; rep++) {
big_vector<size_t> dims(rng() % 7);
for(auto &n: dims) {n = 1 + rng() % 3;}
shapes.push_back(dims);
}
for(auto const& dims: shapes) {
fft::multivar<T> a(dims), b(dims);
for(auto &x: a.data) {x = rng() % T::mod();}
for(auto &x: b.data) {x = rng() % T::mod();}
auto original = a.data, rhs = b.data;
auto want = naive(dims, original, rhs);
a.mul(b);
assert(a.data == want && b.data == rhs && a.dim == dims);
a.data = original;
want = naive(dims, original, original);
a.mul(a);
assert(a.data == want);
for(auto &x: a.data) {x = T::mod()-1;}
b.data = a.data;
want = naive(dims, a.data, b.data);
a.mul(b);
assert(a.data == want);
}
// Both mutable and const spans remain usable without an explicit template argument.
big_vector<T> a{1, 2, 3, 4}, b{5, 6, 7, 8};
auto x = subset_convolution(std::span(a), std::span(b));
auto y = subset_convolution(std::span<T const>(a), std::span<T const>(b));
assert(x == y && x == naive(big_vector<size_t>{2, 2}, a, b));
// Exercise the rank cap and the largest supported ternary expansion with a closed-form oracle.
std::vector<big_vector<size_t>> large{big_vector<size_t>(9, 2)};
if(max_logn == 20) {
large.push_back(big_vector<size_t>(20, 2));
large.push_back({3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3});
}
for(auto const& dims: large) {
fft::multivar<T> f(dims);
std::ranges::fill(f.data, T::mod()-1);
f.mul(f);
for(size_t i = 0; i < f.N; i++) {
size_t j = i;
T want = 1;
for(auto n: dims) {want *= T(j % n + 1); j /= n;}
assert(f.data[i] == want);
}
}
}
int main() {
check<modint<998244353>>();
check<modint<1000000007>>();
dynamic_modint<>::with_mod(998244353, [] {check<dynamic_modint<>>();});
std::cout << "Multivariate products, squares, unit axes and const inputs passed under two primes and dynamic modint\n";
}
#line 1 "cp-algo/math/multivar.hpp"
#line 1 "cp-algo/util/big_alloc.hpp"
#include <set>
#include <map>
#include <deque>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <cstddef>
#include <iostream>
#include <forward_list>
#if defined(__linux__) || defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
# define CP_ALGO_USE_MMAP 1
# include <sys/mman.h>
#else
# define CP_ALGO_USE_MMAP 0
#endif
namespace cp_algo{template<typename T,size_t Align=32>class big_alloc{static_assert(Align>=alignof(void*),"Align must be at least pointer-size");static_assert(std::popcount(Align)==1,"Align must be a power of two");public:using value_type=T;template<class U>struct rebind{using other=big_alloc<U,Align>;};constexpr bool operator==(const big_alloc&)const=default;constexpr bool operator!=(const big_alloc&)const=default;big_alloc()noexcept=default;template<typename U,std::size_t A>big_alloc(const big_alloc<U,A>&)noexcept{}[[nodiscard]]T*allocate(std::size_t n){std::size_t padded=round_up(n*sizeof(T));std::size_t align=std::max<std::size_t>(alignof(T),Align);
#if CP_ALGO_USE_MMAP
if(padded>=MEGABYTE){void*raw=mmap(nullptr,padded,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);madvise(raw,padded,MADV_HUGEPAGE);return static_cast<T*>(raw);}
#endif
return static_cast<T*>(::operator new(padded,std::align_val_t(align)));}void deallocate(T*p,std::size_t n)noexcept{if(!p)return;std::size_t padded=round_up(n*sizeof(T));std::size_t align=std::max<std::size_t>(alignof(T),Align);
#if CP_ALGO_USE_MMAP
if(padded>=MEGABYTE){munmap(p,padded);return;}
#endif
::operator delete(p,padded,std::align_val_t(align));}private:static constexpr std::size_t MEGABYTE=1<<20;static constexpr std::size_t round_up(std::size_t x)noexcept{return(x+Align-1)/Align*Align;}};template<typename T>using big_vector=std::vector<T,big_alloc<T>>;template<typename T>using big_basic_string=std::basic_string<T,std::char_traits<T>,big_alloc<T>>;template<typename T>using big_deque=std::deque<T,big_alloc<T>>;template<typename T>using big_stack=std::stack<T,big_deque<T>>;template<typename T>using big_queue=std::queue<T,big_deque<T>>;template<typename T>using big_priority_queue=std::priority_queue<T,big_vector<T>>;template<typename T>using big_forward_list=std::forward_list<T,big_alloc<T>>;using big_string=big_basic_string<char>;template<typename Key,typename Value,typename Compare=std::less<Key>>using big_map=std::map<Key,Value,Compare,big_alloc<std::pair<const Key,Value>>>;template<typename T,typename Compare=std::less<T>>using big_multiset=std::multiset<T,Compare,big_alloc<T>>;template<typename T,typename Compare=std::less<T>>using big_set=std::set<T,Compare,big_alloc<T>>;}
#line 1 "cp-algo/number_theory/modint.hpp"
#line 1 "cp-algo/math/common.hpp"
#include <functional>
#include <cstdint>
#include <cassert>
#include <bit>
#line 8 "cp-algo/math/common.hpp"
#include <algorithm>
namespace cp_algo::math{
#ifdef CP_ALGO_MAXN
const int maxn=CP_ALGO_MAXN;
#else
const int maxn=1<<19;
#endif
const int magic=64;template<int window=1>auto bpow(auto const&x,auto n,auto const&one,auto op){static_assert(window>=1&&window<=6);if constexpr(window>1){if(n==0){return one;}int bits=std::bit_width(uint64_t(n));auto low_bit=[&](int high){int low=std::max(0,high-window+1);while(!((n>>low)&1)){low++;}return low;};int first=low_bit(bits-1);int cost=(1<<(window-1))+first;for(int j=first-1;j>=0;){if(!((n>>j)&1)){j--;}else{cost++;j=low_bit(j)-1;}}if(cost>=bits+std::popcount(uint64_t(n))-2){return bpow<1>(x,n,one,op);}using T=std::decay_t<decltype(x)>;std::vector<T>odd;odd.reserve(1<<(window-1));odd.push_back(x);auto square=op(x,x);while(odd.size()<size_t(1<<(window-1))){odd.push_back(op(odd.back(),square));}auto ans=odd[(n>>first)/2];for(int j=first-1;j>=0;){if(!((n>>j)&1)){ans=op(ans,ans);j--;}else{int low=low_bit(j),length=j-low+1;auto digit=(n>>low)&((1u<<length)-1);for(int i=0;i<length;i++){ans=op(ans,ans);}ans=op(ans,odd[digit/2]);j=low-1;}}return ans;}else{if(n==0){return one;}auto ans=x;for(int j=std::bit_width<uint64_t>(n)-2;~j;j--){ans=op(ans,ans);if((n>>j)&1){ans=op(ans,x);}}return ans;}}template<int window=1>auto bpow(auto x,auto n,auto ans){return bpow<window>(x,n,ans,std::multiplies{});}template<typename T>T bpow(T const&x,auto n){return bpow(x,n,T(1));}inline constexpr auto inv2(auto x){assert(x%2);std::make_unsigned_t<decltype(x)>y=1;while(y*x!=1){y*=2-x*y;}return y;}}
#line 6 "cp-algo/number_theory/modint.hpp"
namespace cp_algo::math{template<typename modint,typename _Int>struct modint_base{using Int=_Int;using UInt=std::make_unsigned_t<Int>;static constexpr size_t bits=sizeof(Int)*8;using Int2=std::conditional_t<bits<=32,int64_t,__int128_t>;using UInt2=std::conditional_t<bits<=32,uint64_t,__uint128_t>;constexpr static Int mod(){return modint::mod();}constexpr static Int remod(){return modint::remod();}constexpr static UInt2 modmod(){return UInt2(mod())*mod();}constexpr modint_base()=default;constexpr modint_base(Int2 rr){to_modint().setr(UInt((rr+modmod())%mod()));}constexpr modint inv()const{return bpow(to_modint(),mod()-2);}modint operator-()const{modint neg;neg.r=std::min(-r,remod()-r);return neg;}modint&operator/=(const modint&t){return to_modint()*=t.inv();}modint&operator*=(const modint&t){r=UInt(UInt2(r)*t.r%mod());return to_modint();}modint&operator+=(const modint&t){r+=t.r;r=std::min(r,r-remod());return to_modint();}modint&operator-=(const modint&t){r-=t.r;r=std::min(r,r+remod());return to_modint();}modint operator+(const modint&t)const{return modint(to_modint())+=t;}modint operator-(const modint&t)const{return modint(to_modint())-=t;}modint operator*(const modint&t)const{return modint(to_modint())*=t;}modint operator/(const modint&t)const{return modint(to_modint())/=t;}auto operator==(const modint&t)const{return to_modint().getr()==t.getr();}auto operator!=(const modint&t)const{return to_modint().getr()!=t.getr();}auto operator<=(const modint&t)const{return to_modint().getr()<=t.getr();}auto operator>=(const modint&t)const{return to_modint().getr()>=t.getr();}auto operator<(const modint&t)const{return to_modint().getr()<t.getr();}auto operator>(const modint&t)const{return to_modint().getr()>t.getr();}Int rem()const{UInt R=to_modint().getr();return R-(R>(UInt)mod()/2)*mod();}constexpr void setr(UInt rr){r=rr;}constexpr UInt getr()const{return r;}static uint64_t modmod8(){return uint64_t(8*modmod());}void add_unsafe(UInt t){r+=t;}void pseudonormalize(){r=std::min(r,r-modmod8());}modint const&normalize(){if(r>=(UInt)mod()){r%=mod();}return to_modint();}void setr_direct(UInt rr){r=rr;}UInt getr_direct()const{return r;}protected:UInt r;private:constexpr modint&to_modint(){return static_cast<modint&>(*this);}constexpr modint const&to_modint()const{return static_cast<modint const&>(*this);}};template<typename modint>concept modint_type=std::is_base_of_v<modint_base<modint,typename modint::Int>,modint>;template<modint_type modint>decltype(std::cin)&operator>>(decltype(std::cin)&in,modint&x){typename modint::UInt r;auto&res=in>>r;x.setr(r);return res;}template<modint_type modint>decltype(std::cout)&operator<<(decltype(std::cout)&out,modint const&x){return out<<x.getr();}template<auto m>struct modint:modint_base<modint<m>,decltype(m)>{using Base=modint_base<modint<m>,decltype(m)>;using Base::Base;static constexpr Base::Int mod(){return m;}static constexpr Base::UInt remod(){return m;}auto getr()const{return Base::r;}};template<typename Int=int>struct dynamic_modint:modint_base<dynamic_modint<Int>,Int>{using Base=modint_base<dynamic_modint<Int>,Int>;using Base::Base;static Base::UInt m_reduce(Base::UInt2 ab){if(mod()%2==0)[[unlikely]]{return typename Base::UInt(ab%mod());}else{typename Base::UInt2 m=typename Base::UInt(ab)*imod();return typename Base::UInt((ab+m*mod())>>Base::bits);}}static Base::UInt m_transform(Base::UInt a){if(mod()%2==0)[[unlikely]]{return a;}else{return m_reduce(a*pw128());}}dynamic_modint&operator*=(const dynamic_modint&t){Base::r=m_reduce(typename Base::UInt2(Base::r)*t.r);return*this;}void setr(Base::UInt rr){Base::r=m_transform(rr);}Base::UInt getr()const{typename Base::UInt res=m_reduce(Base::r);return std::min(res,res-mod());}static Int mod(){return m;}static Int remod(){return 2*m;}static Base::UInt imod(){return im;}static Base::UInt2 pw128(){return r2;}static void switch_mod(Int nm){m=nm;im=m%2?inv2(-m):0;r2=static_cast<Base::UInt>(static_cast<Base::UInt2>(-1)%m+1);}auto static with_mod(Int tmp,auto callback){struct scoped{Int prev=mod();~scoped(){switch_mod(prev);}}_;switch_mod(tmp);return callback();}private:static thread_local Int m;static thread_local Base::UInt im,r2;};template<typename Int>Int thread_local dynamic_modint<Int>::m=1;template<typename Int>dynamic_modint<Int>::Base::UInt thread_local dynamic_modint<Int>::im=-1;template<typename Int>dynamic_modint<Int>::Base::UInt thread_local dynamic_modint<Int>::r2=0;}
#line 1 "cp-algo/math/fft.hpp"
#line 1 "cp-algo/math/dft.hpp"
#line 1 "cp-algo/util/checkpoint.hpp"
#line 5 "cp-algo/util/checkpoint.hpp"
#include <chrono>
#line 8 "cp-algo/util/checkpoint.hpp"
namespace cp_algo{
#ifdef CP_ALGO_CHECKPOINT
big_map<big_string,double>checkpoints;double last;
#endif
template<bool final=false>void checkpoint([[maybe_unused]]auto const&_msg){
#ifdef CP_ALGO_CHECKPOINT
big_string msg=_msg;double now=(double)clock()/CLOCKS_PER_SEC;double delta=now-last;last=now;if(msg.size()&&!final){checkpoints[msg]+=delta;}if(final){for(auto const&[key,value]:checkpoints){std::cerr<<key<<": "<<value*1000<<" ms\n";}std::cerr<<"Total: "<<now*1000<<" ms\n";}
#endif
}template<bool final=false>void checkpoint(){checkpoint<final>("");}}
#line 1 "cp-algo/random/rng.hpp"
#line 4 "cp-algo/random/rng.hpp"
#include <random>
namespace cp_algo::random{std::mt19937_64 gen(std::chrono::steady_clock::now().time_since_epoch().count());uint64_t rng(){return gen();}}
#line 1 "cp-algo/math/cvector.hpp"
#line 1 "cp-algo/util/simd.hpp"
#include <experimental/simd>
#line 6 "cp-algo/util/simd.hpp"
#include <memory>
#if defined(__x86_64__) && !defined(CP_ALGO_DISABLE_AVX2)
#define CP_ALGO_SIMD_AVX2_TARGET _Pragma("GCC target(\"avx2\")")
#else
#define CP_ALGO_SIMD_AVX2_TARGET
#endif
#define CP_ALGO_SIMD_PRAGMA_PUSH _Pragma("GCC push_options") CP_ALGO_SIMD_AVX2_TARGET
CP_ALGO_SIMD_PRAGMA_PUSH
namespace cp_algo{template<typename T,size_t len>using simd[[gnu::vector_size(len*sizeof(T))]]=T;using u64x8=simd<uint64_t,8>;using u32x16=simd<uint32_t,16>;using i64x4=simd<int64_t,4>;using u64x4=simd<uint64_t,4>;using u32x8=simd<uint32_t,8>;using u16x16=simd<uint16_t,16>;using i32x4=simd<int32_t,4>;using u32x4=simd<uint32_t,4>;using u16x8=simd<uint16_t,8>;using u16x4=simd<uint16_t,4>;using i16x4=simd<int16_t,4>;using u8x32=simd<uint8_t,32>;using u8x16=simd<uint8_t,16>;using u8x8=simd<uint8_t,8>;using u8x4=simd<uint8_t,4>;using dx4=simd<double,4>;inline dx4 abs(dx4 a){return dx4{std::abs(a[0]),std::abs(a[1]),std::abs(a[2]),std::abs(a[3])};}static constexpr dx4 magic=dx4()+(3ULL<<51);inline i64x4 lround(dx4 x){return i64x4(x+magic)-i64x4(magic);}inline dx4 to_double(i64x4 x){return dx4(x+i64x4(magic))-magic;}inline dx4 round(dx4 a){return dx4{std::nearbyint(a[0]),std::nearbyint(a[1]),std::nearbyint(a[2]),std::nearbyint(a[3])};}inline u64x4 low32(u64x4 x){return x&uint32_t(-1);}inline auto swap_bytes(auto x){return decltype(x)(__builtin_shufflevector(u32x8(x),u32x8(x),1,0,3,2,5,4,7,6));}inline u64x4 montgomery_reduce(u64x4 x,uint32_t mod,uint32_t imod){
#ifdef __AVX2__
auto x_ninv=u64x4(_mm256_mul_epu32(__m256i(x),__m256i()+imod));x+=u64x4(_mm256_mul_epu32(__m256i(x_ninv),__m256i()+mod));
#else
auto x_ninv=u64x4(u32x8(low32(x))*imod);x+=x_ninv*uint64_t(mod);
#endif
return swap_bytes(x);}inline u64x4 montgomery_mul(u64x4 x,u64x4 y,uint32_t mod,uint32_t imod){
#ifdef __AVX2__
return montgomery_reduce(u64x4(_mm256_mul_epu32(__m256i(x),__m256i(y))),mod,imod);
#else
return montgomery_reduce(x*y,mod,imod);
#endif
}inline u32x8 montgomery_mul(u32x8 x,u32x8 y,uint32_t mod,uint32_t imod){return u32x8(montgomery_mul(u64x4(x),u64x4(y),mod,imod))|u32x8(swap_bytes(montgomery_mul(u64x4(swap_bytes(x)),u64x4(swap_bytes(y)),mod,imod)));}inline dx4 rotate_right(dx4 x){static constexpr u64x4 shuffler={3,0,1,2};return __builtin_shuffle(x,shuffler);}template<std::size_t Align=32>inline bool is_aligned(const auto*p)noexcept{return(reinterpret_cast<std::uintptr_t>(p)%Align)==0;}template<class Target>inline Target&vector_cast(auto&&p){return*reinterpret_cast<Target*>(std::assume_aligned<alignof(Target)>(&p));}}
#pragma GCC pop_options
#line 1 "cp-algo/util/complex.hpp"
#line 4 "cp-algo/util/complex.hpp"
#include <cmath>
#include <type_traits>
#line 7 "cp-algo/util/complex.hpp"
CP_ALGO_SIMD_PRAGMA_PUSH
namespace cp_algo{template<typename T>struct complex{using value_type=T;T x,y;inline constexpr complex():x(),y(){}inline constexpr complex(T const&x):x(x),y(){}inline constexpr complex(T const&x,T const&y):x(x),y(y){}inline complex&operator*=(T const&t){x*=t;y*=t;return*this;}inline complex&operator/=(T const&t){x/=t;y/=t;return*this;}inline complex operator*(T const&t)const{return complex(*this)*=t;}inline complex operator/(T const&t)const{return complex(*this)/=t;}inline complex&operator+=(complex const&t){x+=t.x;y+=t.y;return*this;}inline complex&operator-=(complex const&t){x-=t.x;y-=t.y;return*this;}inline complex operator*(complex const&t)const{return{x*t.x-y*t.y,x*t.y+y*t.x};}inline complex operator/(complex const&t)const{return*this*t.conj()/t.norm();}inline complex operator+(complex const&t)const{return complex(*this)+=t;}inline complex operator-(complex const&t)const{return complex(*this)-=t;}inline complex&operator*=(complex const&t){return*this=*this*t;}inline complex&operator/=(complex const&t){return*this=*this/t;}inline complex operator-()const{return{-x,-y};}inline complex conj()const{return{x,-y};}inline T norm()const{return x*x+y*y;}inline T abs()const{return std::sqrt(norm());}inline T const real()const{return x;}inline T const imag()const{return y;}inline T&real(){return x;}inline T&imag(){return y;}inline static constexpr complex polar(T r,T theta){return{T(r*cos(theta)),T(r*sin(theta))};}inline auto operator<=>(complex const&t)const=default;};template<typename T>inline complex<T>conj(complex<T>const&x){return x.conj();}template<typename T>inline T norm(complex<T>const&x){return x.norm();}template<typename T>inline T abs(complex<T>const&x){return x.abs();}template<typename T>inline T&real(complex<T>&x){return x.real();}template<typename T>inline T&imag(complex<T>&x){return x.imag();}template<typename T>inline T const real(complex<T>const&x){return x.real();}template<typename T>inline T const imag(complex<T>const&x){return x.imag();}template<typename T>inline constexpr complex<T>polar(T r,T theta){return complex<T>::polar(r,theta);}template<typename T>inline std::ostream&operator<<(std::ostream&out,complex<T>const&x){return out<<x.real()<<' '<<x.imag();}}
#pragma GCC pop_options
#line 7 "cp-algo/math/cvector.hpp"
#include <ranges>
#line 9 "cp-algo/math/cvector.hpp"
CP_ALGO_SIMD_PRAGMA_PUSH
namespace stdx=std::experimental;namespace cp_algo::math::fft{static constexpr size_t flen=4;using ftype=double;using vftype=dx4;using point=complex<ftype>;using vpoint=complex<vftype>;static constexpr vftype vz={};vpoint vi(vpoint const&r){return{-imag(r),real(r)};}struct cvector{big_vector<vpoint>r;cvector(size_t n){n=std::max(flen,std::bit_ceil(n));r.resize(n/flen);prepare_roots(n/16);checkpoint("cvector create");}vpoint&at(size_t k){return r[k/flen];}vpoint at(size_t k)const{return r[k/flen];}template<class pt=point>inline void set(size_t k,pt const&t){if constexpr(std::is_same_v<pt,point>){real(r[k/flen])[k%flen]=real(t);imag(r[k/flen])[k%flen]=imag(t);}else{at(k)=t;}}template<class pt=point>inline pt get(size_t k)const{if constexpr(std::is_same_v<pt,point>){return{real(r[k/flen])[k%flen],imag(r[k/flen])[k%flen]};}else{return at(k);}}size_t size()const{return flen*r.size();}static constexpr size_t eval_arg(size_t n){if(n<pre_evals){return eval_args[n];}else{return eval_arg(n/2)|(n&1)<<(std::bit_width(n)-1);}}static constexpr point eval_point(size_t n){if(n%2){return-eval_point(n-1);}else if(n%4){return eval_point(n-2)*point(0,1);}else if(n/4<pre_evals){return evalp[n/4];}else if(n/4-pre_evals<extra.size()){return extra[n/4-pre_evals];}else{return polar<ftype>(1.,std::numbers::pi/(ftype)std::bit_floor(n)*(ftype)eval_arg(n));}}static constexpr std::array<point,32>roots=[](){std::array<point,32>res;for(size_t i=2;i<32;i++){res[i]=polar<ftype>(1.,std::numbers::pi/(1ull<<(i-2)));}return res;}();static constexpr point root(size_t n){return roots[std::bit_width(n)];}template<int step>static void exec_on_eval(size_t n,size_t k,auto&&callback){callback(k,root(4*step*n)*eval_point(step*k));}template<int step>static void exec_on_evals(size_t n,auto&&callback){point factor=root(4*step*n);for(size_t i=0;i<n;i++){callback(i,factor*eval_point(step*i));}}static void do_dot_iter(point rt,vpoint&Bv,vpoint const&Av,vpoint&res){res+=Av*Bv;real(Bv)=rotate_right(real(Bv));imag(Bv)=rotate_right(imag(Bv));auto x=real(Bv)[0],y=imag(Bv)[0];real(Bv)[0]=x*real(rt)-y*imag(rt);imag(Bv)[0]=x*imag(rt)+y*real(rt);}void dot(cvector const&t){size_t n=this->size();exec_on_evals<1>(n/flen,[&](size_t k,point rt)__attribute__((always_inline)){k*=flen;auto[Ax,Ay]=at(k);auto Bv=t.at(k);vpoint res=vz;for(size_t i=0;i<flen;i++){vpoint Av=vpoint(vz+Ax[i],vz+Ay[i]);do_dot_iter(rt,Bv,Av,res);}set(k,res);});checkpoint("dot");}template<bool partial=true,bool normalize=true>void ifft(){size_t n=size();if constexpr(!partial){prepare_roots(n/4);point pi(0,1);exec_on_evals<4>(n/4,[&](size_t k,point rt)__attribute__((always_inline)){k*=4;point v1=conj(rt);point v2=v1*v1;point v3=v1*v2;auto A=get(k);auto B=get(k+1);auto C=get(k+2);auto D=get(k+3);set(k,(A+B)+(C+D));set(k+2,((A+B)-(C+D))*v2);set(k+1,((A-B)-pi*(C-D))*v1);set(k+3,((A-B)+pi*(C-D))*v3);});}bool parity=std::countr_zero(n)%2;if(parity){exec_on_evals<2>(n/(2*flen),[&](size_t k,point rt)__attribute__((always_inline)){k*=2*flen;vpoint cvrt={vz+real(rt),vz-imag(rt)};auto B=at(k)-at(k+flen);at(k)+=at(k+flen);at(k+flen)=B*cvrt;});}transform<true>(n,parity);checkpoint("ifft");if constexpr(normalize){auto scale=vz+ftype(partial?flen:1)/ftype(n);for(size_t k=0;k<n;k+=flen){set(k,get<vpoint>(k)*scale);}}}template<bool partial=true>void fft(){size_t n=size();prepare_roots(n/(partial?16:4));bool parity=std::countr_zero(n)%2;transform<false>(n,parity);if(parity){exec_on_evals<2>(n/(2*flen),[&](size_t k,point rt)__attribute__((always_inline)){k*=2*flen;vpoint vrt={vz+real(rt),vz+imag(rt)};auto t=at(k+flen)*vrt;at(k+flen)=at(k)-t;at(k)+=t;});}if constexpr(!partial){prepare_roots(n/4);point pi(0,1);exec_on_evals<4>(n/4,[&](size_t k,point rt)__attribute__((always_inline)){k*=4;point v1=rt;point v2=v1*v1;point v3=v1*v2;auto A=get(k);auto B=get(k+1)*v1;auto C=get(k+2)*v2;auto D=get(k+3)*v3;set(k,(A+C)+(B+D));set(k+1,(A+C)-(B+D));set(k+2,(A-C)+pi*(B-D));set(k+3,(A-C)-pi*(B-D));});}checkpoint("fft");}static constexpr size_t pre_evals=1<<16;static const std::array<size_t,pre_evals>eval_args;static const std::array<point,pre_evals>evalp;private:template<bool inverse>void transform(size_t n,bool parity){auto butterfly=[&](size_t offset,size_t length,size_t begin,size_t end)__attribute__((always_inline)){size_t i=length/4;point rt=root(16*n/length)*eval_point(4*offset/length);vpoint v1={vz+real(rt),inverse?vz-imag(rt):vz+imag(rt)};vpoint v2=v1*v1,v3=v1*v2;for(size_t j=offset+begin;j<offset+end;j+=flen){auto A=at(j),B=at(j+i),C=at(j+2*i),D=at(j+3*i);if constexpr(inverse){at(j)=(A+B)+(C+D);at(j+2*i)=((A+B)-(C+D))*v2;at(j+i)=((A-B)-vi(C-D))*v1;at(j+3*i)=((A-B)+vi(C-D))*v3;}else{B=B*v1;C=C*v2;D=D*v3;at(j)=(A+C)+(B+D);at(j+i)=(A+C)-(B+D);at(j+2*i)=(A-C)+vi(B-D);at(j+3*i)=(A-C)-vi(B-D);}}};auto recurse=[&](auto&&self,size_t offset,size_t length)->void{if(length<4*flen){return;}if(length>=(1<<15)){size_t step=length/16;if constexpr(inverse){for(size_t t=0;t<16;t++){self(self,offset+t*step,step);}}for(size_t j=0;j<step;j+=256){size_t end=std::min(step,j+256);if constexpr(inverse){for(size_t t=0;t<4;t++){butterfly(offset+t*length/4,length/4,j,end);}for(size_t t=0;t<4;t++){butterfly(offset,length,j+t*step,end+t*step);}}else{for(size_t t=0;t<4;t++){butterfly(offset,length,j+t*step,end+t*step);}for(size_t t=0;t<4;t++){butterfly(offset+t*length/4,length/4,j,end);}}}if constexpr(!inverse){for(size_t t=0;t<16;t++){self(self,offset+t*step,step);}}}else{if constexpr(inverse){for(size_t leaf=offset+3*flen;leaf<offset+length;leaf+=4*flen){size_t level=std::min<size_t>(std::countr_one(leaf+3),std::countr_zero(length));for(size_t lvl=4+parity;lvl<=level;lvl+=2){size_t len=size_t(1)<<lvl;butterfly(leaf/len*len,len,0,len/4);}}}else{for(size_t leaf=offset;leaf<offset+length;leaf+=4*flen){size_t level=std::min<size_t>(std::countr_zero(n+leaf),std::countr_zero(length));level-=level%2!=parity;for(size_t lvl=level;lvl>=4;lvl-=2){size_t len=size_t(1)<<lvl;butterfly(leaf/len*len,len,0,len/4);}}}}};recurse(recurse,0,n);}static big_vector<point>extra;static void prepare_roots(size_t n){if(n<=pre_evals+extra.size()){return;}size_t old=extra.size();extra.resize(std::bit_ceil(n)-pre_evals);for(size_t i=old;i<extra.size();i++){size_t j=4*(i+pre_evals);extra[i]=polar<ftype>(1.,std::numbers::pi/(ftype)std::bit_floor(j)*(ftype)eval_arg(j));}}};big_vector<point>cvector::extra;const std::array<size_t,cvector::pre_evals>cvector::eval_args=[](){std::array<size_t,pre_evals>res={};for(size_t i=1;i<pre_evals;i++){res[i]=res[i>>1]|(i&1)<<(std::bit_width(i)-1);}return res;}();const std::array<point,cvector::pre_evals>cvector::evalp=[](){std::array<point,pre_evals>res={};res[0]=1;for(size_t n=1;n<pre_evals;n++){res[n]=polar<ftype>(1.,std::numbers::pi*ftype(eval_args[n])/ftype(4*std::bit_floor(n)));}return res;}();}
#pragma GCC pop_options
#line 9 "cp-algo/math/dft.hpp"
CP_ALGO_SIMD_PRAGMA_PUSH
namespace cp_algo::math::fft{template<modint_type base>struct dft{cvector A,B;static base factor,ifactor;using Int2=base::Int2;static bool _init;static int split(){static const int splt=int(std::sqrt(base::mod()))+1;return splt;}static uint32_t mod,imod;static void init(){if(!_init){factor=1+random::rng()%(base::mod()-1);ifactor=base(1)/factor;mod=base::mod();imod=-inv2<uint32_t>(base::mod());_init=true;}}static std::pair<vftype,vftype>do_split(auto const&a,size_t idx,u64x4 mul){if(idx>=std::size(a)){return std::pair{vftype(),vftype()};}u64x4 au={idx<std::size(a)?a[idx].getr():0,idx+1<std::size(a)?a[idx+1].getr():0,idx+2<std::size(a)?a[idx+2].getr():0,idx+3<std::size(a)?a[idx+3].getr():0};au=montgomery_mul(au,mul,mod,imod);au=au>=base::mod()?au-base::mod():au;auto ai=to_double(i64x4(au>=base::mod()/2?au-base::mod():au));auto quo=round(ai*(1.0/split()));return std::pair{ai-quo*split(),quo};}dft(size_t n):A(n),B(n){init();}dft(auto const&a,size_t n,bool partial=true):A(0),B(0){A.r.clear();B.r.clear();size_t blocks=std::max(flen,std::bit_ceil(n))/flen;A.r.reserve(blocks);B.r.reserve(blocks);init();base b2x32=bpow(base(2),32);u64x4 cur={(bpow(factor,1)*b2x32).getr(),(bpow(factor,2)*b2x32).getr(),(bpow(factor,3)*b2x32).getr(),(bpow(factor,4)*b2x32).getr()};u64x4 step4=u64x4{}+(bpow(factor,4)*b2x32).getr();u64x4 stepn=u64x4{}+(bpow(factor,n)*b2x32).getr();for(size_t i=0;i<std::min(n,std::size(a));i+=flen){auto[rai,qai]=do_split(a,i,cur);auto[rani,qani]=do_split(a,n+i,montgomery_mul(cur,stepn,mod,imod));A.r.emplace_back(rai,rani);B.r.emplace_back(qai,qani);cur=montgomery_mul(cur,step4,mod,imod);}A.r.resize(blocks);B.r.resize(blocks);checkpoint("dft init");if(n){if(partial){A.fft();B.fft();}else{A.template fft<false>();B.template fft<false>();}}}template<bool overwrite=true,bool partial=true>void dot(auto const&C,auto const&D,auto&Aout,auto&Bout,auto&Cout)const{cvector::exec_on_evals<1>(A.size()/flen,[&](size_t k,point rt)__attribute__((always_inline)){k*=flen;vpoint AC,AD,BC,BD;AC=AD=BC=BD=vz;auto Cv=C.at(k),Dv=D.at(k);if constexpr(partial){auto[Ax,Ay]=A.at(k);auto[Bx,By]=B.at(k);vpoint vrt={vz+real(rt),vz+imag(rt)};auto Cr=Cv*vrt,Dr=Dv*vrt;auto iter=[&]<int i>()__attribute__((always_inline)){auto wrap=[&](vftype original,vftype rotated){if constexpr(i==0){return original;}else{return __builtin_shufflevector(rotated,original,4-i,5-i,6-i,7-i);}};vpoint Cw={wrap(real(Cv),real(Cr)),wrap(imag(Cv),imag(Cr))};vpoint Dw={wrap(real(Dv),real(Dr)),wrap(imag(Dv),imag(Dr))};vpoint Av={vz+Ax[i],vz+Ay[i]},Bv={vz+Bx[i],vz+By[i]};AC+=Av*Cw;AD+=Av*Dw;BC+=Bv*Cw;BD+=Bv*Dw;};iter.template operator()<0>();iter.template operator()<1>();iter.template operator()<2>();iter.template operator()<3>();}else{AC=A.at(k)*Cv;AD=A.at(k)*Dv;BC=B.at(k)*Cv;BD=B.at(k)*Dv;}if constexpr(overwrite){Aout.at(k)=AC;Cout.at(k)=AD+BC;Bout.at(k)=BD;}else{Aout.at(k)+=AC;Cout.at(k)+=AD+BC;Bout.at(k)+=BD;}});checkpoint("dot");}void dot(auto&&C,auto const&D){dot(C,D,A,B,C);}static void do_recover_iter(size_t idx,auto A,auto B,auto C,auto mul,uint64_t splitsplit,auto&res){auto A0=lround(A),A1=lround(C),A2=lround(B);auto Ai=A0+A1*split()+A2*splitsplit+(uint64_t(base::mod())<<31);auto Au=montgomery_reduce(u64x4(Ai),mod,imod);Au=montgomery_mul(Au,mul,mod,imod);Au=Au>=base::mod()?Au-base::mod():Au;for(size_t j=0;j<flen;j++){res[idx+j].setr(typename base::UInt(Au[j]));}}template<bool normalized=true>void recover_mod(auto&&C,auto&res,size_t k){size_t check=(k+flen-1)/flen*flen;assert(res.size()>=check);size_t n=A.size();auto scale=vz+ftype(flen)/ftype(n);auto const splitsplit=base(split()*split()).getr();base b2x32=bpow(base(2),32);base b2x64=bpow(base(2),64);u64x4 cur={(bpow(ifactor,2)*b2x64).getr(),(bpow(ifactor,3)*b2x64).getr(),(bpow(ifactor,4)*b2x64).getr(),(bpow(ifactor,5)*b2x64).getr()};u64x4 step4=u64x4{}+(bpow(ifactor,4)*b2x32).getr();u64x4 stepn=u64x4{}+(bpow(ifactor,n)*b2x32).getr();for(size_t i=0;i<std::min(n,k);i+=flen){auto get=[&](auto const&x){if constexpr(normalized){return x.at(i);}else{return x.at(i)*scale;}};auto[Ax,Ay]=get(A);auto[Bx,By]=get(B);auto[Cx,Cy]=get(C);do_recover_iter(i,Ax,Bx,Cx,cur,splitsplit,res);if(i+n<k){do_recover_iter(i+n,Ay,By,Cy,montgomery_mul(cur,stepn,mod,imod),splitsplit,res);}cur=montgomery_mul(cur,step4,mod,imod);}checkpoint("recover mod");}void mul(auto&&C,auto const&D,auto&res,size_t k){assert(A.size()==C.size());size_t n=A.size();if(!n){res={};return;}dot(C,D);A.template ifft<true,false>();B.template ifft<true,false>();C.template ifft<true,false>();recover_mod<false>(C,res,k);}void mul_inplace(auto&&B,auto&res,size_t k){mul(B.A,B.B,res,k);}void mul(auto const&B,auto&res,size_t k){mul(cvector(B.A),B.B,res,k);}big_vector<base>operator*=(dft&B){big_vector<base>res(2*A.size());mul_inplace(B,res,2*A.size());return res;}big_vector<base>operator*=(dft const&B){big_vector<base>res(2*A.size());mul(B,res,2*A.size());return res;}auto operator*(dft const&B)const{return dft(*this)*=B;}point operator[](int i)const{return A.get(i);}};template<modint_type base>base dft<base>::factor=1;template<modint_type base>base dft<base>::ifactor=1;template<modint_type base>bool dft<base>::_init=false;template<modint_type base>uint32_t dft<base>::mod={};template<modint_type base>uint32_t dft<base>::imod={};}
#pragma GCC pop_options
#line 4 "cp-algo/math/fft.hpp"
CP_ALGO_SIMD_PRAGMA_PUSH
namespace cp_algo::math::fft{void mul_slow(auto&a,auto const&b,size_t k){if(!std::empty(a)&&std::data(a)==std::data(b)){using base=std::decay_t<decltype(a[0])>;size_t n=std::min(k,std::size(a)),m=std::min(k,std::size(b));if(!m){a.clear();return;}a.resize(k);for(size_t j=k;j-->0;){base sum=0;size_t lo=j>=n?j+1-n:0,hi=std::min(j+1,m);for(size_t i=lo;i<hi;i++){if(n==m&&i>j-i){break;}auto term=a[i]*a[j-i];sum+=n==m&&i!=j-i?term+term:term;}a[j]=sum;}return;}if(std::empty(a)||std::empty(b)){a.clear();}else{size_t n=std::min(k,std::size(a));size_t m=std::min(k,std::size(b));a.resize(k);for(int j=int(k-1);j>=0;j--){a[j]*=b[0];for(int i=std::max(j-(int)n,0)+1;i<std::min(j+1,(int)m);i++){a[j]+=a[j-i]*b[i];}}}}size_t com_size(size_t as,size_t bs){if(!as||!bs){return 0;}return std::max(flen,std::bit_ceil(as+bs-1)/2);}void mul_truncate(auto&a,auto const&b,size_t k){using base=std::decay_t<decltype(a[0])>;if(std::min({k,std::size(a),std::size(b)})<magic){mul_slow(a,b,k);return;}auto n=std::max(flen,std::bit_ceil(std::min(k,std::size(a))+std::min(k,std::size(b))-1)/2);size_t as=std::min(k,std::size(a)),bs=std::min(k,std::size(b));size_t tail=as+bs-1-n;if(tail<=32&&as<=n&&bs<=n){std::array<base,32>high{};for(size_t i=0;i<tail;i++){for(size_t j=n+i-bs+1;j<as;j++){high[i]+=a[j]*b[n+i-j];}}auto A=dft<base>(a|std::views::take(k),n/2);if(as==bs&&std::data(a)==std::data(b)){a.resize((k+flen-1)/flen*flen);A.mul(A,a,std::min(k,n));}else{auto B=dft<base>(b|std::views::take(k),n/2);a.resize((k+flen-1)/flen*flen);A.mul_inplace(B,a,std::min(k,n));}auto wrap=bpow(dft<base>::factor,n);for(size_t i=0;i<tail;i++){a[i]+=wrap*high[i];if(n+i<k){a[n+i]=high[i];}}a.resize(k);return;}auto A=dft<base>(a|std::views::take(k),n);if(as==bs&&std::data(a)==std::data(b)){a.resize((k+flen-1)/flen*flen);A.mul(A,a,k);}else{auto B=dft<base>(b|std::views::take(k),n);a.resize((k+flen-1)/flen*flen);A.mul_inplace(B,a,k);}a.resize(k);}template<bool inverse=false>void mod_split(auto&&x,size_t n,auto k){using base=std::decay_t<decltype(k)>;dft<base>::init();assert(std::size(x)==2*n);u64x4 cur=u64x4{}+(k*bpow(base(2),32)).getr();for(size_t i=0;i<n;i+=flen){u64x4 xl={x[i].getr(),x[i+1].getr(),x[i+2].getr(),x[i+3].getr()};u64x4 xr={x[n+i].getr(),x[n+i+1].getr(),x[n+i+2].getr(),x[n+i+3].getr()};if constexpr(!inverse){xr=montgomery_mul(xr,cur,dft<base>::mod,dft<base>::imod);xr=xr>=base::mod()?xr-base::mod():xr;}auto t=xr;xr=xl-t;xl+=t;xl=xl>=base::mod()?xl-base::mod():xl;xr=xr>=base::mod()?xr+base::mod():xr;if constexpr(inverse){xl=(xl+(xl&1)*base::mod())>>1;xr=montgomery_mul(xr,cur,dft<base>::mod,dft<base>::imod);xr=xr>=base::mod()?xr-base::mod():xr;}for(size_t k=0;k<flen;k++){x[i+k].setr(typename base::UInt(xl[k]));x[n+i+k].setr(typename base::UInt(xr[k]));}}cp_algo::checkpoint(inverse?"mod join":"mod split");}void cyclic_mul(auto&a,auto&&b,size_t k,bool zero_upper=false){assert(std::popcount(k)==1);assert(std::size(a)==std::size(b)&&std::size(a)==k);using base=std::decay_t<decltype(a[0])>;dft<base>::init();bool square=std::data(a)==std::data(b);if(k<=(1<<16)){big_vector<base>ap(begin(a),end(a));if(square){mul_truncate(ap,ap,2*k);}else{mul_truncate(ap,b,2*k);}mod_split(ap,k,bpow(dft<base>::factor,k));std::ranges::copy(ap|std::views::take(k),begin(a));return;}k/=2;auto factor=bpow(dft<base>::factor,k);if(zero_upper){std::ranges::copy(std::span(a).first(k),begin(a)+k);if(!square){std::ranges::copy(std::span(b).first(k),begin(b)+k);}}else{mod_split(a,k,factor);if(!square){mod_split(b,k,factor);}}auto la=std::span(a).first(k);auto lb=std::span(b).first(k);auto ra=std::span(a).last(k);auto rb=std::span(b).last(k);cyclic_mul(la,lb,k);auto A=dft<base>(ra,k/2);if(square){A.mul(A,ra,k);}else{auto B=dft<base>(rb,k/2);A.mul_inplace(B,ra,k);}base i2=base(2).inv();factor=factor.inv()*i2;mod_split<true>(a,k,factor);}auto make_copy(auto&&x){return x;}void cyclic_mul(auto&a,auto const&b,size_t k){return cyclic_mul(a,make_copy(b),k);}namespace impl{void mul_unbalanced(auto&a,auto const&b){using base=std::decay_t<decltype(a[0])>;auto x=std::span<base const>(a),y=std::span<base const>(b);if(x.size()<y.size()){std::swap(x,y);}constexpr size_t length=1<<15;size_t step=length-y.size()+1;auto fixed=dft<base>(y,length/2);std::decay_t<decltype(a)>result(x.size()+y.size()-1);big_vector<base>work(length);for(size_t start=0;start<x.size();start+=step){size_t count=std::min(step,x.size()-start);auto block=dft<base>(x.subspan(start,count),length/2);size_t need=count+y.size()-1;block.mul(fixed,work,need);for(size_t i=0;i<need;i++){result[start+i]+=work[i];}}a=std::move(result);}}void mul(auto&a,auto&&b){if(std::empty(a)||std::empty(b)){a.clear();return;}bool square=std::data(a)==std::data(b)&&std::size(a)==std::size(b);if(!square&&std::data(a)==std::data(b)){auto copy=make_copy(b);return mul(a,copy);}size_t small=std::min(size(a),size(b)),large=std::max(size(a),size(b));if(small>=magic&&small<=4096&&large>=(1<<20)&&large/small>=64){return impl::mul_unbalanced(a,b);}using base=std::decay_t<decltype(a[0])>;size_t N=size(a)+size(b);if(N>(1<<20)){N--;size_t NN=std::bit_ceil(N);bool zero_upper=std::max(size(a),size(b))<=NN/2;a.resize(NN);if(zero_upper&&!square){size_t half=NN/2;b.resize(half);auto lo=std::span(a).first(half),hi=std::span(a).last(half);{auto A=dft<base>(lo,half/2);auto B=dft<base>(b,half/2);A.mul_inplace(B,hi,half);}cyclic_mul(lo,b,half);mod_split<true>(a,half,(base(2)*bpow(dft<base>::factor,half)).inv());}else{if(!square){b.resize(NN);}cyclic_mul(a,b,NN,zero_upper);}a.resize(N);}else{mul_truncate(a,b,N-1);}}void mul(auto&a,auto const&b){if(std::empty(a)||std::empty(b)){a.clear();return;}size_t small=std::min(size(a),size(b)),large=std::max(size(a),size(b));if(small>=magic&&small<=4096&&large>=(1<<20)&&large/small>=64){return impl::mul_unbalanced(a,b);}size_t N=size(a)+size(b);if(N>(1<<20)){if(std::data(a)==std::data(b)&&std::size(a)==std::size(b)){mul(a,a);}else{mul(a,make_copy(b));}}else{mul_truncate(a,b,N-1);}}}
#pragma GCC pop_options
#line 1 "cp-algo/math/subset_convolution.hpp"
#line 1 "cp-algo/util/bit.hpp"
#line 6 "cp-algo/util/bit.hpp"
#include <array>
#line 8 "cp-algo/util/bit.hpp"
#if defined(__x86_64__) && !defined(CP_ALGO_DISABLE_AVX2)
#define CP_ALGO_BIT_OPS_TARGET _Pragma("GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")")
#else
#define CP_ALGO_BIT_OPS_TARGET _Pragma("GCC target(\"bmi,bmi2,lzcnt,popcnt\")")
#endif
#define CP_ALGO_BIT_PRAGMA_PUSH _Pragma("GCC push_options") CP_ALGO_BIT_OPS_TARGET
CP_ALGO_BIT_PRAGMA_PUSH
namespace cp_algo{template<typename Uint>constexpr size_t bit_width=sizeof(Uint)*8;uint64_t mask(size_t n){return(1ULL<<n)-1;}size_t order_of_bit(auto x,size_t k){return k?std::popcount(x<<(bit_width<decltype(x)>-k)):0;}inline size_t kth_set_bit(uint64_t x,size_t k){return std::countr_zero(_pdep_u64(1ULL<<k,x));}template<int fl=0>void with_bit_floor(size_t n,auto&&callback){if constexpr(fl>=63){return;}else if(n>>(fl+1)){with_bit_floor<fl+1>(n,callback);}else{callback.template operator()<1ULL<<fl>();}}void with_bit_ceil(size_t n,auto&&callback){with_bit_floor(n,[&]<size_t N>(){if(N==n){callback.template operator()<N>();}else{callback.template operator()<N<<1>();}});}inline uint32_t read_bits(char const*p){return _mm256_movemask_epi8(__m256i(vector_cast<u8x32 const>(p[0])+(127-'0')));}inline uint64_t read_bits64(char const*p){return read_bits(p)|(uint64_t(read_bits(p+32))<<32);}inline void write_bits(char*p,uint32_t bits){static constexpr u8x32 shuffler={0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3};auto shuffled=u8x32(_mm256_shuffle_epi8(__m256i()+bits,__m256i(shuffler)));static constexpr u8x32 mask={1,2,4,8,16,32,64,128,1,2,4,8,16,32,64,128,1,2,4,8,16,32,64,128,1,2,4,8,16,32,64,128};for(int z=0;z<32;z++){p[z]=shuffled[z]&mask[z]?'1':'0';}}inline void write_bits64(char*p,uint64_t bits){write_bits(p,uint32_t(bits));write_bits(p+32,uint32_t(bits>>32));}}
#pragma GCC pop_options
#line 11 "cp-algo/math/subset_convolution.hpp"
#include <cstring>
CP_ALGO_SIMD_PRAGMA_PUSH
namespace cp_algo::math{
#ifndef CP_ALGO_SUBSET_CONVOLUTION_MAX_LOGN
#define CP_ALGO_SUBSET_CONVOLUTION_MAX_LOGN 20
#endif
const size_t max_logn=CP_ALGO_SUBSET_CONVOLUTION_MAX_LOGN;template<auto N>inline void xor_transform(auto&&a){if constexpr(N>>max_logn){throw std::runtime_error("N too large for xor_transform");}else if constexpr(N<=32){for(size_t i=1;i<N;i*=2){for(size_t j=0;j<N;j+=2*i){for(size_t k=j;k<j+i;k++){for(size_t z=0;z<max_logn;z++){auto x=a[k][z]+a[k+i][z];auto y=a[k][z]-a[k+i][z];a[k][z]=x;a[k+i][z]=y;}}}}}else{auto add=[&](auto&a,auto&b)__attribute__((always_inline)){auto x=a+b,y=a-b;a=x,b=y;};constexpr auto quar=N/4;for(size_t i=0;i<(size_t)quar;i++){auto x0=a[i+(size_t)quar*0];auto x1=a[i+(size_t)quar*1];auto x2=a[i+(size_t)quar*2];auto x3=a[i+(size_t)quar*3];
#pragma GCC unroll max_logn
for(size_t z=0;z<max_logn;z++){add(x0[z],x2[z]);add(x1[z],x3[z]);}
#pragma GCC unroll max_logn
for(size_t z=0;z<max_logn;z++){add(x0[z],x1[z]);add(x2[z],x3[z]);}a[i+(size_t)quar*0]=x0;a[i+(size_t)quar*1]=x1;a[i+(size_t)quar*2]=x2;a[i+(size_t)quar*3]=x3;}xor_transform<quar>(&a[quar*0]);xor_transform<quar>(&a[quar*1]);xor_transform<quar>(&a[quar*2]);xor_transform<quar>(&a[quar*3]);}}inline void xor_transform(auto&&a,auto n){with_bit_floor(n,[&]<auto NN>(){assert(NN==n);xor_transform<NN>(a);});}inline void xor_transform(auto&&a){xor_transform(a,std::size(a));}auto on_rank_vectors(auto&&cb,auto const&...inputs){static_assert(sizeof...(inputs)>=1,"on_rank_vectors requires at least one input");auto input_tuple=std::forward_as_tuple(inputs...);auto const&first_input=std::get<0>(input_tuple);using base=std::decay_t<decltype(first_input[0])>;big_vector<base>out(std::size(first_input));auto N=std::size(first_input);constexpr size_t K=4;N=std::max(N,2*K);const size_t n=std::bit_width(N)-1;const size_t T=std::min<size_t>(n-3,2);const size_t bottoms=1<<(n-T-1);const auto M=std::size(first_input);auto create_buffers=[bottoms]<typename... Args>(const Args&...){return std::make_tuple(big_vector<std::array<typename std::decay_t<Args>::value_type,max_logn>>(bottoms)...);};auto buffers=std::apply(create_buffers,input_tuple);checkpoint("alloc buffers");big_vector<uint32_t>counts(2*bottoms);for(size_t i=1;i<2*bottoms;i++){counts[i]=(uint32_t)std::popcount(i);}checkpoint("prepare");for(size_t top=0;top<N/2;top+=bottoms){std::apply([bottoms](auto&... bufs){(...,memset(bufs.data(),0,sizeof(bufs[0])*bottoms));},buffers);checkpoint("memset");std::apply([&](auto const&... inps){std::apply([&](auto&... bufs){auto init_one=[&](auto const&inp,auto&buf){for(size_t i=0;i<M;i+=2*bottoms){bool parity=__builtin_parity(uint32_t((i>>1)&top));size_t limit=std::min(M,i+2*bottoms)-i;uint32_t count=(uint32_t)std::popcount(i)-1;for(size_t bottom=(i==0);bottom<limit;bottom++){if(parity){buf[bottom>>1][count+counts[bottom]]-=inp[i+bottom];}else{buf[bottom>>1][count+counts[bottom]]+=inp[i+bottom];}}}};(init_one(inps,bufs),...);},buffers);},input_tuple);checkpoint("init");std::apply([](auto&... bufs){(...,xor_transform(bufs));},buffers);checkpoint("transform");assert(bottoms%K==0);for(size_t i=0;i<bottoms;i+=K){std::apply([&](auto&... bufs){auto extract_one=[&](auto&buf){std::array<u64x4,max_logn>aa;for(size_t j=0;j<max_logn;j++){for(size_t z=0;z<K;z++){aa[j][z]=buf[i+z][j].getr();}}return aa;};auto aa_tuple=std::make_tuple(extract_one(bufs)...);std::apply(cb,aa_tuple);auto&first_buf=std::get<0>(std::forward_as_tuple(bufs...));const auto&first_aa=std::get<0>(aa_tuple);for(size_t j=0;j<max_logn;j++){for(size_t z=0;z<K;z++){first_buf[i+z][j].setr((uint32_t)first_aa[j][z]);}}},buffers);}checkpoint("dot");auto&first_buf=std::get<0>(buffers);xor_transform(first_buf);checkpoint("transform");for(size_t i=0;i<M;i+=2*bottoms){bool parity=__builtin_parity(uint32_t((i>>1)&top));size_t limit=std::min(M,i+2*bottoms)-i;uint32_t count=(uint32_t)std::popcount(i)-1;for(size_t bottom=(i==0);bottom<limit;bottom++){if(parity){out[i+bottom]-=first_buf[bottom>>1][count+counts[bottom]];}else{out[i+bottom]+=first_buf[bottom>>1][count+counts[bottom]];}}}checkpoint("gather");}const base ni=base(N/2).inv();for(auto&x:out){x*=ni;}return out;}template<typename value_type>big_vector<std::remove_const_t<value_type>>subset_convolution(std::span<value_type>f,std::span<value_type>g){using base=std::remove_const_t<value_type>;big_vector<base>outpa;const size_t lgn=std::min<size_t>(max_logn,std::bit_width(f.size())-1);outpa=on_rank_vectors([lgn](auto&a,auto const&b){std::decay_t<decltype(a)>res={};const auto mod=base::mod();const auto imod=math::inv2(-mod);const auto r4=u64x4()+uint64_t(-1)%mod+1;auto add=[&](size_t i){for(size_t j=0;i+j+1<lgn;j++){res[i+j+1]+=(u64x4)_mm256_mul_epu32(__m256i(a[i]),__m256i(b[j]));}if(i==15){for(size_t k=0;k<lgn;k++){res[k]-=(res[k]>=base::modmod8())&base::modmod8();}}};for(size_t i=0;i<lgn;i++){add(i);}for(size_t k=0;k<max_logn;k++){res[k]=montgomery_reduce(res[k],mod,imod);res[k]=montgomery_mul(res[k],r4,mod,imod);a[k]=res[k]>=mod?res[k]-mod:res[k];}},f,g);outpa[0]=f[0]*g[0];for(size_t i=1;i<std::size(f);i++){outpa[i]+=f[i]*g[0]+f[0]*g[i];}checkpoint("fix 0");return outpa;}template<typename base>big_vector<base>subset_div(std::span<base>f,std::span<base>g){big_vector<base>outpa;constexpr size_t lgn=max_logn;auto inv=g[0].inv();auto f0=(f[0]*inv).getr(),gi=inv.getr();const auto mod=base::mod();const auto imod=math::inv2(-mod);const auto gir4=u64x4()+(uint64_t(-1)%mod+1)*gi%mod;const size_t period=mod<(1u<<30)?8:1;const uint64_t bound=uint64_t(period*base::modmod());outpa=on_rank_vectors([=](auto&a,auto const&b){for(size_t k=0;k<lgn;k++){for(size_t i=0;i<k;i++){a[k]-=(u64x4)_mm256_mul_epu32(__m256i(a[i]),__m256i(b[k-1-i]));if(i%period==period-1||i+1==k){a[k]=a[k]>=bound?a[k]+bound:a[k];}}a[k]-=(u64x4)_mm256_mul_epu32(__m256i()+f0,__m256i(b[k]));a[k]=a[k]>=bound?a[k]+bound:a[k];a[k]=montgomery_reduce(a[k],mod,imod);a[k]=montgomery_mul(a[k],gir4,mod,imod);a[k]=a[k]>=mod?a[k]-mod:a[k];}},f,g);outpa[0]=f0;checkpoint("fix 0");return outpa;}template<typename base>big_vector<base>subset_log(std::span<base>g){if(size(g)==1){assert(g[0]==base(1));return big_vector<base>{0};}size_t N=std::size(g);auto out0=subset_log(std::span(g).first(N/2));auto out1=subset_div<base>(std::span(g).last(N/2),std::span(g).first(N/2));out0.insert(end(out0),begin(out1),end(out1));cp_algo::checkpoint("extend out");return out0;}template<typename base>big_vector<base>subset_exp(std::span<base>g){if(size(g)==1){assert(g[0]==base(0));return big_vector<base>{1};}size_t N=std::size(g);auto out0=subset_exp(std::span(g).first(N/2));auto out1=subset_convolution<base>(out0,std::span(g).last(N/2));out0.insert(end(out0),begin(out1),end(out1));cp_algo::checkpoint("extend out");return out0;}template<typename base>big_vector<big_vector<base>>subset_compose(std::span<base>f,std::span<base>g,size_t n){if(size(g)==1){size_t M=size(f);big_vector res(n,big_vector<base>{0});big_vector<base>pw(std::max(n,M)+1);pw[0]=1;for(size_t j=1;j<M;j++){pw[j]=pw[j-1]*g[0];}for(size_t i=0;i<n;i++){for(size_t j=0;j<M;j++){res[i][0]+=pw[j]*f[j];}for(size_t j=M;j>i;j--){pw[j]=pw[j-1]*base(j);}pw[i]=0;}cp_algo::checkpoint("base case");return res;}size_t N=std::size(g);auto deeper=subset_compose(f,std::span(g).first(N/2),n+1);for(size_t i=0;i+1<size(deeper);i++){auto next=subset_convolution<base>(deeper[i+1],std::span(g).last(N/2));deeper[i].insert(end(deeper[i]),begin(next),end(next));}deeper.pop_back();cp_algo::checkpoint("combine");return deeper;}template<typename base>big_vector<base>subset_compose(std::span<base>f,std::span<base>g){return subset_compose(f,g,1)[0];}template<typename base>big_vector<base>subset_conv_transpose(std::span<base>h,std::span<base>g){std::ranges::reverse(h);auto res=subset_convolution<base>(h,g);std::ranges::reverse(h);std::ranges::reverse(res);return res;}template<typename base>big_vector<base>subset_power_projection(big_vector<big_vector<base>>&&fg,std::span<base>g,size_t M){if(size(g)==1){size_t n=size(fg);big_vector<base>res(M);big_vector<base>pw(std::max(n,M)+1);pw[0]=1;for(size_t j=1;j<M;j++){pw[j]=pw[j-1]*g[0];}for(size_t i=0;i<size(fg);i++){for(size_t j=0;j<M;j++){res[j]+=pw[j]*fg[i][0];}for(size_t j=M;j>i;j--){pw[j]=pw[j-1]*base(j);}pw[i]=0;}cp_algo::checkpoint("base case");return res;}size_t N=std::size(g);fg.emplace_back(N/2);for(auto&&[i,h]:fg|std::views::enumerate|std::views::reverse|std::views::drop(1)){auto prev=subset_conv_transpose<base>(std::span(h).last(N/2),std::span(g).last(N/2));for(size_t j=0;j<N/2;j++){fg[i+1][j]+=prev[j];}fg[i+1].resize(N/2);}fg[0].resize(N/2);cp_algo::checkpoint("decombine");return subset_power_projection(std::move(fg),std::span(g).first(N/2),M);}template<typename base>big_vector<base>subset_power_projection(std::span<base>g,std::span<base>w,size_t M){return subset_power_projection({{begin(w),end(w)}},g,M);}}
#pragma GCC pop_options
#line 7 "cp-algo/math/multivar.hpp"
CP_ALGO_SIMD_PRAGMA_PUSH
namespace cp_algo::math::fft{template<modint_type base>struct multivar{big_vector<base>data;big_vector<size_t>ranks;big_vector<size_t>dim;size_t N;size_t rank(size_t i){size_t cur=1,res=0,K=size(dim);if(K==0)return 0;for(auto ni:dim){cur*=ni;res+=i/cur;}return res%K;}static void copy_prefix(big_vector<base>&dst,big_vector<size_t>const&dst_dim,big_vector<base>const&src,big_vector<size_t>const&src_dim,big_vector<size_t>const&iter_dim,size_t iter_N){size_t K=iter_dim.size();if(K==0){dst[0]=src[0];return;}if(K==1){std::copy_n(src.data(),iter_dim[0],dst.data());return;}if(K==2){size_t rows=iter_dim[1],cols=iter_dim[0];for(size_t j=0;j<rows;j++){std::copy_n(src.data()+j*src_dim[0],cols,dst.data()+j*dst_dim[0]);}return;}big_vector<size_t>src_stride(K),dst_stride(K);src_stride[0]=1;dst_stride[0]=1;for(size_t i=1;i<K;i++){src_stride[i]=src_stride[i-1]*src_dim[i-1];dst_stride[i]=dst_stride[i-1]*dst_dim[i-1];}big_vector<size_t>idx(K);size_t src_index=0,dst_index=0;for(size_t t=0;t<iter_N;t++){dst[dst_index]=src[src_index];for(size_t d=0;d<K;d++){idx[d]++;src_index+=src_stride[d];dst_index+=dst_stride[d];if(idx[d]<iter_dim[d]){break;}idx[d]=0;src_index-=src_stride[d]*iter_dim[d];dst_index-=dst_stride[d]*iter_dim[d];}}}multivar(auto const&dim):dim(begin(dim),end(dim)),N(std::ranges::fold_left(dim,1,std::multiplies{})){data.resize(N);ranks.resize(N);for(auto[i,x]:ranks|std::views::enumerate){x=rank(i);}checkpoint("multivar init");}size_t linear_index(auto const&idx)const{size_t pos=0,stride=1;size_t K=dim.size();for(size_t i=0;i<K;i++){pos+=idx[i]*stride;stride*=dim[i];}return pos;}template<class Idx>requires requires(Idx const&idx){idx[0];}base&operator[](Idx const&idx){return data[linear_index(idx)];}template<class Idx>requires requires(Idx const&idx){idx[0];}base const&operator[](Idx const&idx)const{return data[linear_index(idx)];}template<std::convertible_to<size_t>... Args>base&operator[](Args... args){size_t idx[]={static_cast<size_t>(args)...};return data[linear_index(idx)];}template<std::convertible_to<size_t>... Args>base const&operator[](Args... args)const{size_t idx[]={static_cast<size_t>(args)...};return data[linear_index(idx)];}void read(){for(auto&it:data){std::cin>>it;}checkpoint("multivar read");}void print(){for(auto&it:data){std::cout<<it<<" ";}std::cout<<"\n";checkpoint("multivar write");}void assign_prefix_from(multivar<base>const&src){assert(dim.size()==src.dim.size());size_t K=dim.size();if(K==0){data[0]=src.data[0];return;}for(size_t i=0;i<K;i++){assert(src.dim[i]<=dim[i]);}copy_prefix(data,dim,src.data,src.dim,src.dim,src.N);}multivar<base>truncated(auto const&new_dim)const{big_vector<size_t>nd(begin(new_dim),end(new_dim));assert(nd.size()==dim.size());for(size_t i=0;i<nd.size();i++){assert(nd[i]<=dim[i]);}multivar<base>out(nd);if(out.N==0){return out;}copy_prefix(out.data,out.dim,data,dim,out.dim,out.N);return out;}void truncate_inplace(auto const&new_dim){big_vector<size_t>nd(begin(new_dim),end(new_dim));assert(nd.size()==dim.size());size_t K=nd.size();for(size_t i=0;i<K;i++){assert(nd[i]<=dim[i]);}size_t new_N=std::ranges::fold_left(nd,1,std::multiplies{});if(new_N==0){data.clear();dim=std::move(nd);ranks.clear();N=0;return;}if(K==1){}else if(K==2){size_t rows=nd[1],cols=nd[0];for(size_t j=1;j<rows;j++){std::copy_n(data.data()+j*dim[0],cols,data.data()+j*cols);}}else{copy_prefix(data,nd,data,dim,nd,new_N);}data.resize(new_N);dim=std::move(nd);N=new_N;ranks.resize(N);for(auto[i,x]:ranks|std::views::enumerate){x=rank(i);}}void mul(multivar<base>const&b){assert(dim==b.dim);size_t K=size(dim);if(K==0){data[0]*=b.data[0];return;}if(mul_subset(b)){return;}big_vector<dft<base>>A,B;size_t M=std::max(flen,std::bit_ceil(2*N-1)/2);for(size_t i=0;i<K;i++){A.emplace_back(data|std::views::enumerate|std::views::transform([&](auto jx){auto[j,x]=jx;return ranks[j]==i?x:base(0);}),M,false);B.emplace_back(b.data|std::views::enumerate|std::views::transform([&](auto jx){auto[j,x]=jx;return ranks[j]==i?x:base(0);}),M,false);}for(size_t i=0;i<K;i++){dft<base>C(M);cvector X=C.A;for(size_t j=0;j<K;j++){size_t tj=(i-j+K)%K;A[j].template dot<false,false>(B[tj].A,B[tj].B,C.A,C.B,X);}checkpoint("dot");big_vector<base>res((N+flen-1)/flen*flen);C.A.template ifft<false>();C.B.template ifft<false>();X.template ifft<false>();C.recover_mod(X,res,N);for(size_t j=0;j<N;j++){if(i==ranks[j]){data[j]=res[j];}}checkpoint("store");}}private:bool mul_subset(multivar const&b){if constexpr(base::bits>32||max_logn<3||max_logn>20){return false;}if(N<64||base::mod()%2==0||base::mod()>=(1<<30)){return false;}size_t bits=0,threes=0;for(auto n:dim){if(n<1||n>3){return false;}bits+=n-1;threes+=n==3;}if(bits>max_logn||threes>7){return false;}if(!threes){data=subset_convolution<base const>(data,b.data);return true;}size_t M=size_t(1)<<bits;big_vector<size_t>index(M);big_vector<uint8_t>degree(M);size_t block=1,stride=1;for(auto n:dim){for(size_t mask=1;mask<(size_t(1)<<(n-1));mask++){size_t rank=std::popcount(mask);for(size_t j=0;j<block;j++){index[mask*block+j]=index[j]+rank*stride;degree[mask*block+j]=degree[j]+(rank==2);}}block<<=n-1;stride*=n;}std::array<base,8>weight,iweight;weight[0]=iweight[0]=1;base half=base(2).inv();for(size_t i=1;i<=threes;i++){weight[i]=weight[i-1]*base(2);iweight[i]=iweight[i-1]*half;}big_vector<base>f(M),g(M);for(size_t i=0;i<M;i++){f[i]=data[index[i]]*weight[degree[i]];g[i]=b.data[index[i]]*weight[degree[i]];}auto h=subset_convolution<base>(f,g);for(size_t i=0;i<M;i++){data[index[i]]=h[i]*iweight[degree[i]];}return true;}};}
#pragma GCC pop_options
#line 4 "tests/multivar.cpp"
using namespace cp_algo;using namespace cp_algo::math;template<typename T>big_vector<T>naive(big_vector<size_t>const&dims,big_vector<T>const&a,big_vector<T>const&b){big_vector<T>result(a.size());for(size_t i=0;i<a.size();i++){for(size_t j=0;i+j<a.size();j++){size_t x=i,y=j;bool carry=false;for(auto n:dims){carry|=x%n+y%n>=n;x/=n;y/=n;}if(!carry){result[i+j]+=a[i]*b[j];}}}return result;}template<typename T>void check(){std::mt19937 rng(59321);std::vector<big_vector<size_t>>shapes{{},{1},{2},{3},{4},{1,2,1,3},{2,2,2,2,2,2},{2,2,2,2,2,2,2},{3,3,3,3},{3,2,3,2,3},{2,3,2,3,2},{5,7},{4,3,2},{31,3},{65,2}};for(int rep=0;rep<80;rep++){big_vector<size_t>dims(rng()%7);for(auto&n:dims){n=1+rng()%3;}shapes.push_back(dims);}for(auto const&dims:shapes){fft::multivar<T>a(dims),b(dims);for(auto&x:a.data){x=rng()%T::mod();}for(auto&x:b.data){x=rng()%T::mod();}auto original=a.data,rhs=b.data;auto want=naive(dims,original,rhs);a.mul(b);assert(a.data==want&&b.data==rhs&&a.dim==dims);a.data=original;want=naive(dims,original,original);a.mul(a);assert(a.data==want);for(auto&x:a.data){x=T::mod()-1;}b.data=a.data;want=naive(dims,a.data,b.data);a.mul(b);assert(a.data==want);}big_vector<T>a{1,2,3,4},b{5,6,7,8};auto x=subset_convolution(std::span(a),std::span(b));auto y=subset_convolution(std::span<T const>(a),std::span<T const>(b));assert(x==y&&x==naive(big_vector<size_t>{2,2},a,b));std::vector<big_vector<size_t>>large{big_vector<size_t>(9,2)};if(max_logn==20){large.push_back(big_vector<size_t>(20,2));large.push_back({3,2,3,2,3,2,3,2,3,2,3,2,3});}for(auto const&dims:large){fft::multivar<T>f(dims);std::ranges::fill(f.data,T::mod()-1);f.mul(f);for(size_t i=0;i<f.N;i++){size_t j=i;T want=1;for(auto n:dims){want*=T(j%n+1);j/=n;}assert(f.data[i]==want);}}}int main(){check<modint<998244353>>();check<modint<1000000007>>();dynamic_modint<>::with_mod(998244353,[]{check<dynamic_modint<>>();});std::cout<<"Multivariate products, squares, unit axes and const inputs passed under two primes and dynamic modint\n";}