This documentation is automatically generated by online-judge-tools/verification-helper
View the Project on GitHub suisen-cp/cp-library-cpp
#include "library/number/fast_discrete_logarithm.hpp"
#ifndef SUISEN_INDEX_CALCULUS #define SUISEN_INDEX_CALCULUS #include <algorithm> #include <array> #include <cassert> #include <cmath> #include <optional> #include <map> #include <atcoder/modint> #include <atcoder/math> #include "library/number/fast_factorize.hpp" #include "library/number/order_Z_mZ.hpp" #include "library/number/discrete_logarithm.hpp" namespace suisen::fast_discrete_logarithm { namespace internal { template <typename mint> struct SystemOfLinearEquations { SystemOfLinearEquations() = default; SystemOfLinearEquations(int target_var_id) : target_var_id(target_var_id) {} void append(std::vector<mint> r, mint bi) { int ti = target_var_id + 1; for (int i = 0; i <= target_var_id; ++i) if (r[i] != 0) { ti = i; break; } if (ti > target_var_id) return; const int l = A.size(); const int start = std::lower_bound(top_pos.begin(), top_pos.end(), ti) - top_pos.begin(); for (int i = start; i < l; ++i) { eliminate(top_pos[i], A[i], b[i], ti, r, bi); if (ti > target_var_id) return; } A.push_back(std::move(r)); top_pos.push_back(ti); b.push_back(bi); } void append(const std::vector<std::pair<int, mint>>& ri, mint bi) { std::vector<mint> r(target_var_id + 1); for (auto [j, v] : ri) r[j] = v; append(std::move(r), bi); } std::optional<mint> target() { if (top_pos.empty() or top_pos.back() != target_var_id) return std::nullopt; auto [g, inv_c] = atcoder::internal::inv_gcd(A.back().back().val(), mint::mod()); return g == 1 ? std::make_optional(b.back() * inv_c) : std::nullopt; } void change_target() { const int l = A.size(); int t = -1; for (int i = l - 1; i >= 0; --i) { if (A[i][target_var_id] != 0) { t = i; break; } } SystemOfLinearEquations<mint> nxt(target_var_id); for (int i = l - 1; i > t; --i) { nxt.append(A[i], b[i]); } for (int i = t - 1; i >= 0; --i) { if (A[i][target_var_id] != 0) { const auto T = euclid(A[t][target_var_id].val(), A[i][target_var_id].val()); for (int col = top_pos[i]; col <= target_var_id; ++col) { apply_euclid(T, A[t][col], A[i][col]); } apply_euclid(T, b[t], b[i]); } nxt.append(A[i], b[i]); } *this = std::move(nxt); } private: int target_var_id; std::vector<std::vector<mint>> A; std::vector<int> top_pos; std::vector<mint> b; // Euclidean Algorithm // A * [a, b] = [gcd(a,b), 0] static std::array<std::array<int, 2>, 2> euclid(int a, int b) { int x = 1, y = 0, z = 0, w = 1; while (b) { int p = a / b, q = a % b; x -= p * z, std::swap(x, z); y -= p * w, std::swap(y, w); a = b, b = q; } return { x, y, z, w }; } static void apply_euclid(const std::array<std::array<int, 2>, 2>& A, mint& x, mint& y) { mint x2 = x, y2 = y; x = A[0][0] * x2 + A[0][1] * y2; y = A[1][0] * x2 + A[1][1] * y2; } static void eliminate(int& ti, std::vector<mint>& ri, mint& bi, int& tj, std::vector<mint>& rj, mint& bj) { if (ti != tj) { if (ti > tj) std::swap(ti, tj), std::swap(ri, rj), std::swap(bi, bj); return; } const int siz = ri.size(); assert(int(rj.size()) == siz); const auto T = euclid(ri[ti].val(), rj[tj].val()); for (int col = ti; col < siz; ++col) { apply_euclid(T, ri[col], rj[col]); } apply_euclid(T, bi, bj); while (tj < siz and rj[tj] == 0) ++tj; } }; } struct IndexCalculus { private: using mint = atcoder::dynamic_modint<73495793>; using mint2 = atcoder::dynamic_modint<73495794>; public: IndexCalculus() = default; IndexCalculus(const OrderMod<int>& ord) : _p(ord.mod()), _ord(ord) { assert(ord.is_prime()); } int operator()(int a, int b, int p) { int old_mod = mint::mod(), old_mod2 = mint2::mod(); mint::set_mod(p), mint2::set_mod(p - 1); int res = discrete_log_impl(a, b, p); mint::set_mod(old_mod), mint2::set_mod(old_mod2); return res; } static int discrete_logarithm(int a, int b, int p) { return IndexCalculus{}(a, b, p); } private: static constexpr int MAX_B = 80; static constexpr uint32_t primes[MAX_B]{ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, }; // inv_primes[i] = ceil(2^32 / primes[i]) static constexpr uint32_t inv_primes[MAX_B]{ 2147483648,1431655766, 858993460, 613566757, 390451573, 330382100, 252645136, 226050911, 186737709, 148102321, 138547333, 116080198, 104755300, 99882961, 91382283, 81037119, 72796056, 70409300, 64103990, 60492498, 58835169, 54366675, 51746594, 48258060, 44278014, 42524429, 41698712, 40139882, 39403370, 38008561, 33818641, 32786010, 31350127, 30899046, 28825284, 28443493, 27356480, 26349493, 25718368, 24826401, 23994231, 23729102, 22486740, 22253717, 21801865, 21582751, 20355296, 19259944, 18920561, 18755316, 18433337, 17970575, 17821442, 17111424, 16711936, 16330675, 15966422, 15848588, 15505298, 15284582, 15176563, 14658592, 13990122, 13810185, 13721941, 13548793, 12975733, 12744711, 12377428, 12306497, 12167047, 11963698, 11702909, 11514658, 11332368, 11214014, 11041048, 10818558, 10710642, 10501143, }; int _p = -1; OrderMod<int> _ord; int _a = -1; internal::SystemOfLinearEquations<mint2> _eq; static int safe_mod(int a, int p) { return ((a %= p) < 0) ? a + p : a; } static int discrete_log_naive(mint a, mint b, int ord_a) { mint pow_a = 1; for (int res = 0; res < ord_a; ++res) { if (pow_a == b) return res; pow_a *= a; } return -1; } static bool is_smooth(const int B, uint32_t v) { assert(B <= MAX_B); for (int i = 0; i < B; ++i) { const uint32_t m = primes[B - i - 1], im = inv_primes[B - i - 1]; if (uint32_t q = (uint64_t(v) * im) >> 32; v == q * m) { // q = floor(v/m) do v = q, q = (uint64_t(v) * im) >> 32; while (v == q * m); } } return v == 1; } static std::optional<std::vector<mint2>> try_factorize(const int B, uint32_t v) { assert(B <= MAX_B); if (not is_smooth(B, v)) return std::nullopt; std::vector<mint2> res(B + 1); for (int i = 0; i < B; ++i) { const uint32_t m = primes[B - i - 1], im = inv_primes[B - i - 1]; int c = 0; uint32_t q = (uint64_t(v) * im) >> 32; while (v == q * m) { v = q, q = (uint64_t(v) * im) >> 32; ++c; } res[i] = c; } res[B] = -1; return res; } int discrete_log_impl(int a, int b, int p) { a = safe_mod(a, p), b = safe_mod(b, p); if (b == 0) return a == 0 ? 1 : -1; if (b == 1) return 0; if (a == 0) return -1; if (a == 1) return -1; if (p <= 64) return discrete_log_naive(a, b, p - 1); const int B = ::pow(p - 1, 1 / (2 * ::sqrt(::log(p - 1) / ::log(::log(p - 1))))) + 5; assert(B <= MAX_B); if (p != _p) { _p = p, _ord = OrderMod<int>(p); _a = a, _eq = internal::SystemOfLinearEquations<mint2>(B); } else if (a != _a) { _a = a, _eq = internal::SystemOfLinearEquations<mint2>(B); } else { _eq.change_target(); } assert(_ord.is_prime()); const int ord_a = _ord(a), ord_b = _ord(b); if (ord_a % ord_b) return -1; if (ord_a <= 64) return discrete_log_naive(a, b, ord_a); static std::mt19937 rng{}; while (true) { const int k = rng() % ord_a; auto opt_fac = try_factorize(B, (mint(a).pow(k) * b).val()); if (not opt_fac) continue; auto& fac = *opt_fac; _eq.append(std::move(fac), k); if (auto res = _eq.target()) return res->val() % ord_a; } } }; namespace internal { using mint = atcoder::dynamic_modint<73495793>; // min{ i | 0 <= i < r and a^i = b } or -1 int naive(int a, int b, int r) { mint pow_a = 1; for (int res = 0; res < r; ++res) { if (pow_a == b) return res; pow_a *= a; } return -1; } int pohlig_hellman_prime_power_bsgs(int a, int b, int ord_a, int p, int q) { // ord_a = p ^ q if (ord_a <= 64) return naive(a, b, ord_a); const mint gamma = mint(a).pow(ord_a / p); const mint inv_a = mint(a).inv(); int x = 0; for (int k = 0, pl = 1, pr = ord_a; k < q; ++k) { pr /= p; int d = suisen::discrete_logarithm_coprime(gamma, (inv_a.pow(x) * b).pow(pr)); if (d == -1) return -1; x += pl * d; pl *= p; } return x; } int pohlig_hellman(int a, int b, int p, int q, const OrderMod<int>& ord) { // gcd(a, p) = 1 if (b == 1) return 0; if (a == 1) return b == 1 ? 0 : -1; if (b % p == 0) return -1; if (q == 1) { return IndexCalculus{ ord }(a, b, p); } const int ord_a = ord(a); if (ord_a <= 64) return naive(a, b, ord_a); if (ord_a % ord(b)) return -1; const std::vector<std::pair<int, int>> ord_factorized = [&] { std::vector<std::pair<int, int>> res; int v = ord_a; for (int p : ord.carmichael_prime_factors()) if (v % p == 0) { int& c = res.emplace_back(p, 0).second; do v /= p, ++c; while (v % p == 0); } return res; }(); std::vector<long long> rs, ms; for (auto [p, q] : ord_factorized) { int pq = 1; for (int i = 0; i < q; ++i) pq *= p; const int na = mint(a).pow(ord_a / pq).val(), nb = mint(b).pow(ord_a / pq).val(); const int x = pohlig_hellman_prime_power_bsgs(na, nb, pq, p, q); if (x == -1) return -1; rs.push_back(x), ms.push_back(pq); } return atcoder::crt(rs, ms).first; } } namespace internal { int discrete_logarithm_coprime(int a, int b) { const int m = mint::mod(); assert(std::gcd(a, m) == 1); long long r = 0, md = 1; for (auto [p, q] : fast_factorize::factorize(m)) { // CRT int pq = 1; for (int i = 0; i < q; ++i) pq *= p; mint::set_mod(pq); OrderMod ord(pq); const long long r2 = pohlig_hellman(mint(a).val(), mint(b).val(), p, q, ord); if (r2 == -1) return -1; const long long md2 = ord(a); std::tie(r, md) = atcoder::crt({ r, r2 }, { md, md2 }); if (md == 0) return -1; } return r; } int discrete_logarithm_arbitrary_mod(int a, int b) { const int m = mint::mod(); if (m == 1 or b == 1) return 0; if (a == 0) return b == 0 ? 1 : b == 1 ? 0 : -1; if (a == 1) return b == 1 ? 0 : -1; const int floor_log2_m = [m] { int res = 0; while (1 << (res + 1) <= m) ++res; return res; }(); if (int i = naive(a, b, floor_log2_m); i != -1) return i; const int pow_a = mint(a).pow(floor_log2_m).val(); const int g = std::gcd(pow_a, m); if (b % g) return -1; mint::set_mod(m / g); const int t = discrete_logarithm_coprime(mint(a).val(), (mint(b) / pow_a).val()); return t != -1 ? floor_log2_m + t : -1; } } int discrete_logarithm(int a, int b, int m) { using internal::mint; const int old_mod = mint::mod(); mint::set_mod(m); const int res = internal::discrete_logarithm_arbitrary_mod(mint(a).val(), mint(b).val()); mint::set_mod(old_mod); return res; } } // namespace suisen #endif // SUISEN_INDEX_CALCULUS
#line 1 "library/number/fast_discrete_logarithm.hpp" #include <algorithm> #include <array> #include <cassert> #include <cmath> #include <optional> #include <map> #include <atcoder/modint> #include <atcoder/math> #line 1 "library/number/fast_factorize.hpp" #line 5 "library/number/fast_factorize.hpp" #include <iostream> #include <random> #include <numeric> #include <utility> #line 1 "library/type_traits/type_traits.hpp" #include <limits> #line 6 "library/type_traits/type_traits.hpp" #include <type_traits> namespace suisen { template <typename ...Constraints> using constraints_t = std::enable_if_t<std::conjunction_v<Constraints...>, std::nullptr_t>; template <typename T, typename = std::nullptr_t> struct bitnum { static constexpr int value = 0; }; template <typename T> struct bitnum<T, constraints_t<std::is_integral<T>>> { static constexpr int value = std::numeric_limits<std::make_unsigned_t<T>>::digits; }; template <typename T> static constexpr int bitnum_v = bitnum<T>::value; template <typename T, size_t n> struct is_nbit { static constexpr bool value = bitnum_v<T> == n; }; template <typename T, size_t n> static constexpr bool is_nbit_v = is_nbit<T, n>::value; template <typename T, typename = std::nullptr_t> struct safely_multipliable { using type = T; }; template <typename T> struct safely_multipliable<T, constraints_t<std::is_signed<T>, is_nbit<T, 32>>> { using type = long long; }; template <typename T> struct safely_multipliable<T, constraints_t<std::is_signed<T>, is_nbit<T, 64>>> { using type = __int128_t; }; template <typename T> struct safely_multipliable<T, constraints_t<std::is_unsigned<T>, is_nbit<T, 32>>> { using type = unsigned long long; }; template <typename T> struct safely_multipliable<T, constraints_t<std::is_unsigned<T>, is_nbit<T, 64>>> { using type = __uint128_t; }; template <typename T> using safely_multipliable_t = typename safely_multipliable<T>::type; template <typename T, typename = void> struct rec_value_type { using type = T; }; template <typename T> struct rec_value_type<T, std::void_t<typename T::value_type>> { using type = typename rec_value_type<typename T::value_type>::type; }; template <typename T> using rec_value_type_t = typename rec_value_type<T>::type; template <typename T> class is_iterable { template <typename T_> static auto test(T_ e) -> decltype(e.begin(), e.end(), std::true_type{}); static std::false_type test(...); public: static constexpr bool value = decltype(test(std::declval<T>()))::value; }; template <typename T> static constexpr bool is_iterable_v = is_iterable<T>::value; template <typename T> class is_writable { template <typename T_> static auto test(T_ e) -> decltype(std::declval<std::ostream&>() << e, std::true_type{}); static std::false_type test(...); public: static constexpr bool value = decltype(test(std::declval<T>()))::value; }; template <typename T> static constexpr bool is_writable_v = is_writable<T>::value; template <typename T> class is_readable { template <typename T_> static auto test(T_ e) -> decltype(std::declval<std::istream&>() >> e, std::true_type{}); static std::false_type test(...); public: static constexpr bool value = decltype(test(std::declval<T>()))::value; }; template <typename T> static constexpr bool is_readable_v = is_readable<T>::value; } // namespace suisen #line 11 "library/number/fast_factorize.hpp" #line 1 "library/number/deterministic_miller_rabin.hpp" #line 6 "library/number/deterministic_miller_rabin.hpp" #include <cstdint> #include <iterator> #include <tuple> #line 10 "library/number/deterministic_miller_rabin.hpp" #line 1 "library/number/montogomery.hpp" #line 7 "library/number/montogomery.hpp" namespace suisen { namespace internal::montgomery { template <typename Int, typename DInt> struct Montgomery { private: static constexpr uint32_t bits = std::numeric_limits<Int>::digits; static constexpr Int mask = ~Int(0); // R = 2**32 or 2**64 // 1. N is an odd number // 2. N < R // 3. gcd(N, R) = 1 // 4. R * R2 - N * N2 = 1 // 5. 0 < R2 < N // 6. 0 < N2 < R Int N, N2, R2; // RR = R * R (mod N) Int RR; public: constexpr Montgomery() = default; explicit constexpr Montgomery(Int N) : N(N), N2(calcN2(N)), R2(calcR2(N, N2)), RR(calcRR(N)) { assert(N & 1); } // @returns t * R (mod N) constexpr Int make(Int t) const { return reduce(static_cast<DInt>(t) * RR); } // @returns T * R^(-1) (mod N) constexpr Int reduce(DInt T) const { // 0 <= T < RN // Note: // 1. m = T * N2 (mod R) // 2. 0 <= m < R DInt m = modR(static_cast<DInt>(modR(T)) * N2); // Note: // T + m * N = T + T * N * N2 = T + T * (R * R2 - 1) = 0 (mod R) // => (T + m * N) / R is an integer. // => t * R = T + m * N = T (mod N) // => t = T R^(-1) (mod N) DInt t = divR(T + m * N); // Note: // 1. 0 <= T < RN // 2. 0 <= mN < RN (because 0 <= m < R) // => 0 <= T + mN < 2RN // => 0 <= t < 2N return t >= N ? t - N : t; } constexpr Int add(Int A, Int B) const { return (A += B) >= N ? A - N : A; } constexpr Int sub(Int A, Int B) const { return (A -= B) < 0 ? A + N : A; } constexpr Int mul(Int A, Int B) const { return reduce(static_cast<DInt>(A) * B); } constexpr Int div(Int A, Int B) const { return reduce(static_cast<DInt>(A) * inv(B)); } constexpr Int inv(Int A) const; // TODO: Implement constexpr Int pow(Int A, long long b) const { Int P = make(1); for (; b; b >>= 1) { if (b & 1) P = mul(P, A); A = mul(A, A); } return P; } private: static constexpr Int divR(DInt t) { return t >> bits; } static constexpr Int modR(DInt t) { return t & mask; } static constexpr Int calcN2(Int N) { // - N * N2 = 1 (mod R) // N2 = -N^{-1} (mod R) // calculates N^{-1} (mod R) by Newton's method DInt invN = N; // = N^{-1} (mod 2^2) for (uint32_t cur_bits = 2; cur_bits < bits; cur_bits *= 2) { // loop invariant: invN = N^{-1} (mod 2^cur_bits) // x = a^{-1} mod m => x(2-ax) = a^{-1} mod m^2 because: // ax = 1 (mod m) // => (ax-1)^2 = 0 (mod m^2) // => 2ax - a^2x^2 = 1 (mod m^2) // => a(x(2-ax)) = 1 (mod m^2) invN = modR(invN * modR(2 - N * invN)); } assert(modR(N * invN) == 1); return modR(-invN); } static constexpr Int calcR2(Int N, Int N2) { // R * R2 - N * N2 = 1 // => R2 = (1 + N * N2) / R return divR(1 + static_cast<DInt>(N) * N2); } static constexpr Int calcRR(Int N) { return -DInt(N) % N; } }; } // namespace internal::montgomery using Montgomery32 = internal::montgomery::Montgomery<uint32_t, uint64_t>; using Montgomery64 = internal::montgomery::Montgomery<uint64_t, __uint128_t>; } // namespace suisen #line 12 "library/number/deterministic_miller_rabin.hpp" namespace suisen::miller_rabin { namespace internal { constexpr uint64_t THRESHOLD_1 = 341531ULL; constexpr uint64_t BASE_1[]{ 9345883071009581737ULL }; constexpr uint64_t THRESHOLD_2 = 1050535501ULL; constexpr uint64_t BASE_2[]{ 336781006125ULL, 9639812373923155ULL }; constexpr uint64_t THRESHOLD_3 = 350269456337ULL; constexpr uint64_t BASE_3[]{ 4230279247111683200ULL, 14694767155120705706ULL, 16641139526367750375ULL }; constexpr uint64_t THRESHOLD_4 = 55245642489451ULL; constexpr uint64_t BASE_4[]{ 2ULL, 141889084524735ULL, 1199124725622454117ULL, 11096072698276303650ULL }; constexpr uint64_t THRESHOLD_5 = 7999252175582851ULL; constexpr uint64_t BASE_5[]{ 2ULL, 4130806001517ULL, 149795463772692060ULL, 186635894390467037ULL, 3967304179347715805ULL }; constexpr uint64_t THRESHOLD_6 = 585226005592931977ULL; constexpr uint64_t BASE_6[]{ 2ULL, 123635709730000ULL, 9233062284813009ULL, 43835965440333360ULL, 761179012939631437ULL, 1263739024124850375ULL }; constexpr uint64_t BASE_7[]{ 2U, 325U, 9375U, 28178U, 450775U, 9780504U, 1795265022U }; template <auto BASE, std::size_t SIZE> constexpr bool miller_rabin(uint64_t n) { if (n == 2 or n == 3 or n == 5 or n == 7) return true; if (n <= 1 or n % 2 == 0 or n % 3 == 0 or n % 5 == 0 or n % 7 == 0) return false; if (n < 121) return true; const uint32_t s = __builtin_ctzll(n - 1); // >= 1 const uint64_t d = (n - 1) >> s; const Montgomery64 mg{ n }; const uint64_t one = mg.make(1), minus_one = mg.make(n - 1); for (std::size_t i = 0; i < SIZE; ++i) { uint64_t a = BASE[i] % n; if (a == 0) continue; uint64_t Y = mg.pow(mg.make(a), d); if (Y == one) continue; for (uint32_t r = 0;; ++r, Y = mg.mul(Y, Y)) { // Y = a^(d 2^r) if (Y == minus_one) break; if (r == s - 1) return false; } } return true; } } template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr> constexpr bool is_prime(T n) { if constexpr (std::is_signed_v<T>) { assert(n >= 0); } const std::make_unsigned_t<T> n_unsigned = n; assert(n_unsigned <= std::numeric_limits<uint64_t>::max()); // n < 2^64 using namespace internal; if (n_unsigned < THRESHOLD_1) return miller_rabin<BASE_1, 1>(n_unsigned); if (n_unsigned < THRESHOLD_2) return miller_rabin<BASE_2, 2>(n_unsigned); if (n_unsigned < THRESHOLD_3) return miller_rabin<BASE_3, 3>(n_unsigned); if (n_unsigned < THRESHOLD_4) return miller_rabin<BASE_4, 4>(n_unsigned); if (n_unsigned < THRESHOLD_5) return miller_rabin<BASE_5, 5>(n_unsigned); if (n_unsigned < THRESHOLD_6) return miller_rabin<BASE_6, 6>(n_unsigned); return miller_rabin<BASE_7, 7>(n_unsigned); } } // namespace suisen::miller_rabin #line 1 "library/number/sieve_of_eratosthenes.hpp" #line 6 "library/number/sieve_of_eratosthenes.hpp" #include <vector> #line 1 "library/number/internal_eratosthenes.hpp" #line 6 "library/number/internal_eratosthenes.hpp" namespace suisen::internal::sieve { constexpr std::uint8_t K = 8; constexpr std::uint8_t PROD = 2 * 3 * 5; constexpr std::uint8_t RM[K] = { 1, 7, 11, 13, 17, 19, 23, 29 }; constexpr std::uint8_t DR[K] = { 6, 4, 2, 4, 2, 4, 6, 2 }; constexpr std::uint8_t DF[K][K] = { { 0, 0, 0, 0, 0, 0, 0, 1 }, { 1, 1, 1, 0, 1, 1, 1, 1 }, { 2, 2, 0, 2, 0, 2, 2, 1 }, { 3, 1, 1, 2, 1, 1, 3, 1 }, { 3, 3, 1, 2, 1, 3, 3, 1 }, { 4, 2, 2, 2, 2, 2, 4, 1 }, { 5, 3, 1, 4, 1, 3, 5, 1 }, { 6, 4, 2, 4, 2, 4, 6, 1 }, }; constexpr std::uint8_t DRP[K] = { 48, 32, 16, 32, 16, 32, 48, 16 }; constexpr std::uint8_t DFP[K][K] = { { 0, 0, 0, 0, 0, 0, 0, 8 }, { 8, 8, 8, 0, 8, 8, 8, 8 }, { 16, 16, 0, 16, 0, 16, 16, 8 }, { 24, 8, 8, 16, 8, 8, 24, 8 }, { 24, 24, 8, 16, 8, 24, 24, 8 }, { 32, 16, 16, 16, 16, 16, 32, 8 }, { 40, 24, 8, 32, 8, 24, 40, 8 }, { 48, 32, 16, 32, 16, 32, 48, 8 }, }; constexpr std::uint8_t MASK[K][K] = { { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 }, { 0x02, 0x20, 0x10, 0x01, 0x80, 0x08, 0x04, 0x40 }, { 0x04, 0x10, 0x01, 0x40, 0x02, 0x80, 0x08, 0x20 }, { 0x08, 0x01, 0x40, 0x20, 0x04, 0x02, 0x80, 0x10 }, { 0x10, 0x80, 0x02, 0x04, 0x20, 0x40, 0x01, 0x08 }, { 0x20, 0x08, 0x80, 0x02, 0x40, 0x01, 0x10, 0x04 }, { 0x40, 0x04, 0x08, 0x80, 0x01, 0x10, 0x20, 0x02 }, { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }, }; constexpr std::uint8_t OFFSET[K][K] = { { 0, 1, 2, 3, 4, 5, 6, 7, }, { 1, 5, 4, 0, 7, 3, 2, 6, }, { 2, 4, 0, 6, 1, 7, 3, 5, }, { 3, 0, 6, 5, 2, 1, 7, 4, }, { 4, 7, 1, 2, 5, 6, 0, 3, }, { 5, 3, 7, 1, 6, 0, 4, 2, }, { 6, 2, 3, 7, 0, 4, 5, 1, }, { 7, 6, 5, 4, 3, 2, 1, 0, }, }; constexpr std::uint8_t mask_to_index(const std::uint8_t bits) { switch (bits) { case 1 << 0: return 0; case 1 << 1: return 1; case 1 << 2: return 2; case 1 << 3: return 3; case 1 << 4: return 4; case 1 << 5: return 5; case 1 << 6: return 6; case 1 << 7: return 7; default: assert(false); } } } // namespace suisen::internal::sieve #line 9 "library/number/sieve_of_eratosthenes.hpp" namespace suisen { template <unsigned int N> class SimpleSieve { private: static constexpr unsigned int siz = N / internal::sieve::PROD + 1; static std::uint8_t flag[siz]; public: SimpleSieve() { using namespace internal::sieve; flag[0] |= 1; unsigned int k_max = (unsigned int) std::sqrt(N + 2) / PROD; for (unsigned int kp = 0; kp <= k_max; ++kp) { for (std::uint8_t bits = ~flag[kp]; bits; bits &= bits - 1) { const std::uint8_t mp = mask_to_index(bits & -bits), m = RM[mp]; unsigned int kr = kp * (PROD * kp + 2 * m) + m * m / PROD; for (std::uint8_t mq = mp; kr < siz; kr += kp * DR[mq] + DF[mp][mq], ++mq &= 7) { flag[kr] |= MASK[mp][mq]; } } } } std::vector<int> prime_list(unsigned int max_val = N) const { using namespace internal::sieve; std::vector<int> res { 2, 3, 5 }; res.reserve(max_val / 25); for (unsigned int i = 0, offset = 0; i < siz and offset < max_val; ++i, offset += PROD) { for (uint8_t f = ~flag[i]; f;) { uint8_t g = f & -f; res.push_back(offset + RM[mask_to_index(g)]); f ^= g; } } while (res.size() and (unsigned int) res.back() > max_val) res.pop_back(); return res; } bool is_prime(const unsigned int p) const { using namespace internal::sieve; switch (p) { case 2: case 3: case 5: return true; default: switch (p % PROD) { case RM[0]: return ((flag[p / PROD] >> 0) & 1) == 0; case RM[1]: return ((flag[p / PROD] >> 1) & 1) == 0; case RM[2]: return ((flag[p / PROD] >> 2) & 1) == 0; case RM[3]: return ((flag[p / PROD] >> 3) & 1) == 0; case RM[4]: return ((flag[p / PROD] >> 4) & 1) == 0; case RM[5]: return ((flag[p / PROD] >> 5) & 1) == 0; case RM[6]: return ((flag[p / PROD] >> 6) & 1) == 0; case RM[7]: return ((flag[p / PROD] >> 7) & 1) == 0; default: return false; } } } }; template <unsigned int N> std::uint8_t SimpleSieve<N>::flag[SimpleSieve<N>::siz]; template <unsigned int N> class Sieve { private: static constexpr unsigned int base_max = (N + 1) * internal::sieve::K / internal::sieve::PROD; static unsigned int pf[base_max + internal::sieve::K]; public: Sieve() { using namespace internal::sieve; pf[0] = 1; unsigned int k_max = ((unsigned int) std::sqrt(N + 1) - 1) / PROD; for (unsigned int kp = 0; kp <= k_max; ++kp) { const int base_i = kp * K, base_act_i = kp * PROD; for (int mp = 0; mp < K; ++mp) { const int m = RM[mp], i = base_i + mp; if (pf[i] == 0) { unsigned int act_i = base_act_i + m; unsigned int base_k = (kp * (PROD * kp + 2 * m) + m * m / PROD) * K; for (std::uint8_t mq = mp; base_k <= base_max; base_k += kp * DRP[mq] + DFP[mp][mq], ++mq &= 7) { pf[base_k + OFFSET[mp][mq]] = act_i; } } } } } bool is_prime(const unsigned int p) const { using namespace internal::sieve; switch (p) { case 2: case 3: case 5: return true; default: switch (p % PROD) { case RM[0]: return pf[p / PROD * K + 0] == 0; case RM[1]: return pf[p / PROD * K + 1] == 0; case RM[2]: return pf[p / PROD * K + 2] == 0; case RM[3]: return pf[p / PROD * K + 3] == 0; case RM[4]: return pf[p / PROD * K + 4] == 0; case RM[5]: return pf[p / PROD * K + 5] == 0; case RM[6]: return pf[p / PROD * K + 6] == 0; case RM[7]: return pf[p / PROD * K + 7] == 0; default: return false; } } } int prime_factor(const unsigned int p) const { using namespace internal::sieve; switch (p % PROD) { case 0: case 2: case 4: case 6: case 8: case 10: case 12: case 14: case 16: case 18: case 20: case 22: case 24: case 26: case 28: return 2; case 3: case 9: case 15: case 21: case 27: return 3; case 5: case 25: return 5; case RM[0]: return pf[p / PROD * K + 0] ? pf[p / PROD * K + 0] : p; case RM[1]: return pf[p / PROD * K + 1] ? pf[p / PROD * K + 1] : p; case RM[2]: return pf[p / PROD * K + 2] ? pf[p / PROD * K + 2] : p; case RM[3]: return pf[p / PROD * K + 3] ? pf[p / PROD * K + 3] : p; case RM[4]: return pf[p / PROD * K + 4] ? pf[p / PROD * K + 4] : p; case RM[5]: return pf[p / PROD * K + 5] ? pf[p / PROD * K + 5] : p; case RM[6]: return pf[p / PROD * K + 6] ? pf[p / PROD * K + 6] : p; case RM[7]: return pf[p / PROD * K + 7] ? pf[p / PROD * K + 7] : p; default: assert(false); } } /** * Returns a vector of `{ prime, index }`. */ std::vector<std::pair<int, int>> factorize(unsigned int n) const { assert(0 < n and n <= N); std::vector<std::pair<int, int>> prime_powers; while (n > 1) { int p = prime_factor(n), c = 0; do { n /= p, ++c; } while (n % p == 0); prime_powers.emplace_back(p, c); } return prime_powers; } /** * Returns the divisors of `n`. * It is NOT guaranteed that the returned vector is sorted. */ std::vector<int> divisors(unsigned int n) const { assert(0 < n and n <= N); std::vector<int> divs { 1 }; for (auto [prime, index] : factorize(n)) { int sz = divs.size(); for (int i = 0; i < sz; ++i) { int d = divs[i]; for (int j = 0; j < index; ++j) { divs.push_back(d *= prime); } } } return divs; } }; template <unsigned int N> unsigned int Sieve<N>::pf[Sieve<N>::base_max + internal::sieve::K]; } // namespace suisen #line 14 "library/number/fast_factorize.hpp" namespace suisen::fast_factorize { namespace internal { template <typename T> constexpr int floor_log2(T n) { int i = 0; while (n) n >>= 1, ++i; return i - 1; } template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr> T pollard_rho(const T n) { using M = safely_multipliable_t<T>; const T m = T(1) << (floor_log2(n) / 5); static std::mt19937_64 rng{std::random_device{}()}; std::uniform_int_distribution<T> dist(0, n - 1); // const Montgomery64 mg{n}; while (true) { T c = dist(rng); auto f = [&](T x) -> T { return (M(x) * x + c) % n; }; T x, y = 2, ys, q = 1, g = 1; for (T r = 1; g == 1; r <<= 1) { x = y; for (T i = 0; i < r; ++i) y = f(y); for (T k = 0; k < r and g == 1; k += m) { ys = y; for (T i = 0; i < std::min(m, r - k); ++i) y = f(y), q = M(q) * (x > y ? x - y : y - x) % n; g = std::gcd(q, n); } } if (g == n) { g = 1; while (g == 1) ys = f(ys), g = std::gcd(x > ys ? x - ys : ys - x, n); } if (g < n) { if (miller_rabin::is_prime(g)) return g; if (T d = n / g; miller_rabin::is_prime(d)) return d; return pollard_rho(g); } } } } template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr> std::vector<std::pair<T, int>> factorize(T n) { static constexpr int threshold = 1000000; static Sieve<threshold> sieve; std::vector<std::pair<T, int>> res; if (n <= threshold) { for (auto [p, q] : sieve.factorize(n)) res.emplace_back(p, q); return res; } if ((n & 1) == 0) { int q = 0; do ++q, n >>= 1; while ((n & 1) == 0); res.emplace_back(2, q); } for (T p = 3; p * p <= n; p += 2) { if (p >= 101 and n >= 1 << 20) { while (n > 1) { if (miller_rabin::is_prime(n)) { res.emplace_back(std::exchange(n, 1), 1); } else { p = internal::pollard_rho(n); int q = 0; do ++q, n /= p; while (n % p == 0); res.emplace_back(p, q); } } break; } if (n % p == 0) { int q = 0; do ++q, n /= p; while (n % p == 0); res.emplace_back(p, q); } } if (n > 1) res.emplace_back(n, 1); return res; } } // namespace suisen::fast_factorize #line 1 "library/number/order_Z_mZ.hpp" #line 6 "library/number/order_Z_mZ.hpp" #line 9 "library/number/order_Z_mZ.hpp" namespace suisen { namespace internal::order_prime_mod { template <int id> struct mint64 { static uint64_t mod() { return _mod; } static void set_mod(uint64_t new_mod) { mint64<id>::_mod = new_mod; } mint64() : _val(0) {} mint64(long long val) : _val(safe_mod(val)) {} uint64_t val() { return _val; } friend mint64& operator*=(mint64& x, const mint64& y) { x._val = __uint128_t(x._val) * y._val % _mod; return x; } friend mint64 operator*(mint64 x, const mint64& y) { x *= y; return x; } mint64 pow(long long b) const { assert(b >= 0); mint64 p = *this, res = 1; for (; b; b >>= 1) { if (b & 1) res *= p; p *= p; } return res; } private: static inline uint64_t _mod; uint64_t _val; static uint64_t safe_mod(long long val) { return (val %= _mod) < 0 ? val + _mod : val; } }; } template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr> struct OrderMod { using U = std::make_unsigned_t<T>; OrderMod() = default; OrderMod(T m) : _mod(m) { auto factorized = fast_factorize::factorize<T>(_mod); _is_prime = factorized.size() == 1; _lambda = _carmichael(factorized); _phi = _totient(factorized); for (auto [p, q] : fast_factorize::factorize<T>(_lambda)) { U r = 1; for (int i = 0; i < q; ++i) r *= p; _fac_lambda.emplace_back(p, q, r); } } bool is_primitive_root(U a) const { if (_mod < 1ULL << 32) { using mint = atcoder::dynamic_modint<1000000000>; U old_mod = mint::mod(); mint::set_mod(_mod); bool res = _is_primitive_root_impl<mint>(a); mint::set_mod(old_mod); return res; } else { using mint = internal::order_prime_mod::mint64<1000000000>; U old_mod = mint::mod(); mint::set_mod(_mod); bool res = _is_primitive_root_impl<mint>(a); mint::set_mod(old_mod); return res; } } T primitive_root() const { assert(_lambda == _phi); if (_mod < 1ULL << 32) { return _primitive_root_impl<std::mt19937>(); } else { return _primitive_root_impl<std::mt19937_64>(); } } T operator()(U a) const { if (_mod < 1ULL << 31) { using mint = atcoder::dynamic_modint<1000000000>; U old_mod = mint::mod(); mint::set_mod(_mod); T res = _order_impl<mint>(a); mint::set_mod(old_mod); return res; } else { using mint = internal::order_prime_mod::mint64<1000000000>; U old_mod = mint::mod(); mint::set_mod(_mod); T res = _order_impl<mint>(a); mint::set_mod(old_mod); return res; } } T mod() const { return _mod; } T totient() const { return _phi; } T carmichael() const { return _lambda; } bool is_prime() const { return _is_prime; } std::vector<T> carmichael_prime_factors() const { std::vector<T> res; for (const auto &e : _fac_lambda) res.push_back(std::get<0>(e)); return res; } private: U _mod; U _phi; U _lambda; bool _is_prime; std::vector<std::tuple<U, int, U>> _fac_lambda; static T _carmichael(const std::vector<std::pair<T, int>>& factorized) { T lambda = 1; for (auto [p, ep] : factorized) { T phi = p - 1; int exponent = ep - (1 + (p == 2 and ep >= 3)); for (int i = 0; i < exponent; ++i) phi *= p; lambda = std::lcm(lambda, phi); } return lambda; } static T _totient(const std::vector<std::pair<T, int>>& factorized) { T t = 1; for (const auto& [p, ep] : factorized) { t *= p - 1; for (int i = 0; i < ep - 1; ++i) t *= p; } return t; } template <typename mint> bool _is_primitive_root_impl(U a) const { if (_lambda != _phi) return false; if (_mod == 2) return a % 2 == 1; const int k = _fac_lambda.size(); U x = _lambda; for (const auto& [p, q, pq] : _fac_lambda) x /= p; mint b = mint(a).pow(x); if (k == 1) return b.val() != 1; auto dfs = [&](auto dfs, const int l, const int r, const mint val) -> bool { const int m = (l + r) >> 1; U lp = 1; for (int i = m; i < r; ++i) lp *= std::get<0>(_fac_lambda[i]); mint lval = val.pow(lp); if (m - l == 1) { if (lval.val() == 1) return false; } else { if (not dfs(dfs, l, m, lval)) return false; } U rp = 1; for (int i = l; i < m; ++i) rp *= std::get<0>(_fac_lambda[i]); mint rval = val.pow(rp); if (r - m == 1) { if (rval.val() == 1) return false; } else { if (not dfs(dfs, m, r, rval)) return false; } return true; }; return dfs(dfs, 0, k, b); } template <typename Rng> T _primitive_root_impl() const { if (_mod == 2) return 1; Rng rng{ std::random_device{}() }; while (true) { U a = rng() % (_mod - 2) + 2; while (not _is_prime and std::gcd(a, _mod) != 1) { a = rng() % (_mod - 2) + 2; } if (is_primitive_root(a)) return a; } } template <typename mint> U _order_impl(U a) const { if (_mod == 2) return a % 2 == 1; const int k = _fac_lambda.size(); U res = 1; auto update = [&](U p, mint val) { while (val.val() != 1) { val = val.pow(p); res *= p; } }; if (k == 1) { update(std::get<0>(_fac_lambda.front()), a); return res; } auto dfs = [&](auto dfs, const int l, const int r, const mint val) -> void { const int m = (l + r) >> 1; U lp = 1; for (int i = m; i < r; ++i) lp *= std::get<2>(_fac_lambda[i]); mint lval = val.pow(lp); if (m - l == 1) { update(std::get<0>(_fac_lambda[l]), lval); } else { dfs(dfs, l, m, lval); } U rp = 1; for (int i = l; i < m; ++i) rp *= std::get<2>(_fac_lambda[i]); mint rval = val.pow(rp); if (r - m == 1) { update(std::get<0>(_fac_lambda[m]), rval); } else { dfs(dfs, m, r, rval); } }; dfs(dfs, 0, k, a); return res; } }; } // namespace suisen #line 1 "library/number/discrete_logarithm.hpp" #line 5 "library/number/discrete_logarithm.hpp" #include <unordered_map> #line 7 "library/number/discrete_logarithm.hpp" namespace suisen { namespace internal::discrete_logarithm { int floor_log2(int m) { int res = 0; while (1 << (res + 1) <= m) ++res; return res; } } template <typename mint> int discrete_logarithm_coprime(mint x, mint y) { const int m = mint::mod(); if (y == 1 or m == 1) return 0; if (x == 0) return y == 0 ? 1 : -1; const int p = ::sqrt(m) + 1; mint a = mint(x).inv().pow(p); std::unordered_map<int, int> mp; mint pow_x = 1; for (int j = 0; j < p; ++j, pow_x *= x) mp.try_emplace(pow_x.val(), j); mint ya = y; for (int i = 0; i < p; ++i, ya *= a) { if (auto it = mp.find(ya.val()); it != mp.end()) return p * i + it->second; } return -1; } template <typename mint> int discrete_logarithm(mint x, mint y) { using namespace internal::discrete_logarithm; const int m = mint::mod(); if (m == 1) return 0; const int d = floor_log2(m); mint pow_x = 1; for (int i = 0; i < d; ++i, pow_x *= x) if (pow_x == y) return i; const int g = std::gcd(pow_x.val(), m); if (y.val() % g) return -1; mint::set_mod(m / g); const int t = discrete_logarithm_coprime(mint(x.val()), mint(y.val()) * mint(pow_x.val()).inv()); mint::set_mod(m); return t != -1 ? d + t : -1; } } // namespace suisen #line 17 "library/number/fast_discrete_logarithm.hpp" namespace suisen::fast_discrete_logarithm { namespace internal { template <typename mint> struct SystemOfLinearEquations { SystemOfLinearEquations() = default; SystemOfLinearEquations(int target_var_id) : target_var_id(target_var_id) {} void append(std::vector<mint> r, mint bi) { int ti = target_var_id + 1; for (int i = 0; i <= target_var_id; ++i) if (r[i] != 0) { ti = i; break; } if (ti > target_var_id) return; const int l = A.size(); const int start = std::lower_bound(top_pos.begin(), top_pos.end(), ti) - top_pos.begin(); for (int i = start; i < l; ++i) { eliminate(top_pos[i], A[i], b[i], ti, r, bi); if (ti > target_var_id) return; } A.push_back(std::move(r)); top_pos.push_back(ti); b.push_back(bi); } void append(const std::vector<std::pair<int, mint>>& ri, mint bi) { std::vector<mint> r(target_var_id + 1); for (auto [j, v] : ri) r[j] = v; append(std::move(r), bi); } std::optional<mint> target() { if (top_pos.empty() or top_pos.back() != target_var_id) return std::nullopt; auto [g, inv_c] = atcoder::internal::inv_gcd(A.back().back().val(), mint::mod()); return g == 1 ? std::make_optional(b.back() * inv_c) : std::nullopt; } void change_target() { const int l = A.size(); int t = -1; for (int i = l - 1; i >= 0; --i) { if (A[i][target_var_id] != 0) { t = i; break; } } SystemOfLinearEquations<mint> nxt(target_var_id); for (int i = l - 1; i > t; --i) { nxt.append(A[i], b[i]); } for (int i = t - 1; i >= 0; --i) { if (A[i][target_var_id] != 0) { const auto T = euclid(A[t][target_var_id].val(), A[i][target_var_id].val()); for (int col = top_pos[i]; col <= target_var_id; ++col) { apply_euclid(T, A[t][col], A[i][col]); } apply_euclid(T, b[t], b[i]); } nxt.append(A[i], b[i]); } *this = std::move(nxt); } private: int target_var_id; std::vector<std::vector<mint>> A; std::vector<int> top_pos; std::vector<mint> b; // Euclidean Algorithm // A * [a, b] = [gcd(a,b), 0] static std::array<std::array<int, 2>, 2> euclid(int a, int b) { int x = 1, y = 0, z = 0, w = 1; while (b) { int p = a / b, q = a % b; x -= p * z, std::swap(x, z); y -= p * w, std::swap(y, w); a = b, b = q; } return { x, y, z, w }; } static void apply_euclid(const std::array<std::array<int, 2>, 2>& A, mint& x, mint& y) { mint x2 = x, y2 = y; x = A[0][0] * x2 + A[0][1] * y2; y = A[1][0] * x2 + A[1][1] * y2; } static void eliminate(int& ti, std::vector<mint>& ri, mint& bi, int& tj, std::vector<mint>& rj, mint& bj) { if (ti != tj) { if (ti > tj) std::swap(ti, tj), std::swap(ri, rj), std::swap(bi, bj); return; } const int siz = ri.size(); assert(int(rj.size()) == siz); const auto T = euclid(ri[ti].val(), rj[tj].val()); for (int col = ti; col < siz; ++col) { apply_euclid(T, ri[col], rj[col]); } apply_euclid(T, bi, bj); while (tj < siz and rj[tj] == 0) ++tj; } }; } struct IndexCalculus { private: using mint = atcoder::dynamic_modint<73495793>; using mint2 = atcoder::dynamic_modint<73495794>; public: IndexCalculus() = default; IndexCalculus(const OrderMod<int>& ord) : _p(ord.mod()), _ord(ord) { assert(ord.is_prime()); } int operator()(int a, int b, int p) { int old_mod = mint::mod(), old_mod2 = mint2::mod(); mint::set_mod(p), mint2::set_mod(p - 1); int res = discrete_log_impl(a, b, p); mint::set_mod(old_mod), mint2::set_mod(old_mod2); return res; } static int discrete_logarithm(int a, int b, int p) { return IndexCalculus{}(a, b, p); } private: static constexpr int MAX_B = 80; static constexpr uint32_t primes[MAX_B]{ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, }; // inv_primes[i] = ceil(2^32 / primes[i]) static constexpr uint32_t inv_primes[MAX_B]{ 2147483648,1431655766, 858993460, 613566757, 390451573, 330382100, 252645136, 226050911, 186737709, 148102321, 138547333, 116080198, 104755300, 99882961, 91382283, 81037119, 72796056, 70409300, 64103990, 60492498, 58835169, 54366675, 51746594, 48258060, 44278014, 42524429, 41698712, 40139882, 39403370, 38008561, 33818641, 32786010, 31350127, 30899046, 28825284, 28443493, 27356480, 26349493, 25718368, 24826401, 23994231, 23729102, 22486740, 22253717, 21801865, 21582751, 20355296, 19259944, 18920561, 18755316, 18433337, 17970575, 17821442, 17111424, 16711936, 16330675, 15966422, 15848588, 15505298, 15284582, 15176563, 14658592, 13990122, 13810185, 13721941, 13548793, 12975733, 12744711, 12377428, 12306497, 12167047, 11963698, 11702909, 11514658, 11332368, 11214014, 11041048, 10818558, 10710642, 10501143, }; int _p = -1; OrderMod<int> _ord; int _a = -1; internal::SystemOfLinearEquations<mint2> _eq; static int safe_mod(int a, int p) { return ((a %= p) < 0) ? a + p : a; } static int discrete_log_naive(mint a, mint b, int ord_a) { mint pow_a = 1; for (int res = 0; res < ord_a; ++res) { if (pow_a == b) return res; pow_a *= a; } return -1; } static bool is_smooth(const int B, uint32_t v) { assert(B <= MAX_B); for (int i = 0; i < B; ++i) { const uint32_t m = primes[B - i - 1], im = inv_primes[B - i - 1]; if (uint32_t q = (uint64_t(v) * im) >> 32; v == q * m) { // q = floor(v/m) do v = q, q = (uint64_t(v) * im) >> 32; while (v == q * m); } } return v == 1; } static std::optional<std::vector<mint2>> try_factorize(const int B, uint32_t v) { assert(B <= MAX_B); if (not is_smooth(B, v)) return std::nullopt; std::vector<mint2> res(B + 1); for (int i = 0; i < B; ++i) { const uint32_t m = primes[B - i - 1], im = inv_primes[B - i - 1]; int c = 0; uint32_t q = (uint64_t(v) * im) >> 32; while (v == q * m) { v = q, q = (uint64_t(v) * im) >> 32; ++c; } res[i] = c; } res[B] = -1; return res; } int discrete_log_impl(int a, int b, int p) { a = safe_mod(a, p), b = safe_mod(b, p); if (b == 0) return a == 0 ? 1 : -1; if (b == 1) return 0; if (a == 0) return -1; if (a == 1) return -1; if (p <= 64) return discrete_log_naive(a, b, p - 1); const int B = ::pow(p - 1, 1 / (2 * ::sqrt(::log(p - 1) / ::log(::log(p - 1))))) + 5; assert(B <= MAX_B); if (p != _p) { _p = p, _ord = OrderMod<int>(p); _a = a, _eq = internal::SystemOfLinearEquations<mint2>(B); } else if (a != _a) { _a = a, _eq = internal::SystemOfLinearEquations<mint2>(B); } else { _eq.change_target(); } assert(_ord.is_prime()); const int ord_a = _ord(a), ord_b = _ord(b); if (ord_a % ord_b) return -1; if (ord_a <= 64) return discrete_log_naive(a, b, ord_a); static std::mt19937 rng{}; while (true) { const int k = rng() % ord_a; auto opt_fac = try_factorize(B, (mint(a).pow(k) * b).val()); if (not opt_fac) continue; auto& fac = *opt_fac; _eq.append(std::move(fac), k); if (auto res = _eq.target()) return res->val() % ord_a; } } }; namespace internal { using mint = atcoder::dynamic_modint<73495793>; // min{ i | 0 <= i < r and a^i = b } or -1 int naive(int a, int b, int r) { mint pow_a = 1; for (int res = 0; res < r; ++res) { if (pow_a == b) return res; pow_a *= a; } return -1; } int pohlig_hellman_prime_power_bsgs(int a, int b, int ord_a, int p, int q) { // ord_a = p ^ q if (ord_a <= 64) return naive(a, b, ord_a); const mint gamma = mint(a).pow(ord_a / p); const mint inv_a = mint(a).inv(); int x = 0; for (int k = 0, pl = 1, pr = ord_a; k < q; ++k) { pr /= p; int d = suisen::discrete_logarithm_coprime(gamma, (inv_a.pow(x) * b).pow(pr)); if (d == -1) return -1; x += pl * d; pl *= p; } return x; } int pohlig_hellman(int a, int b, int p, int q, const OrderMod<int>& ord) { // gcd(a, p) = 1 if (b == 1) return 0; if (a == 1) return b == 1 ? 0 : -1; if (b % p == 0) return -1; if (q == 1) { return IndexCalculus{ ord }(a, b, p); } const int ord_a = ord(a); if (ord_a <= 64) return naive(a, b, ord_a); if (ord_a % ord(b)) return -1; const std::vector<std::pair<int, int>> ord_factorized = [&] { std::vector<std::pair<int, int>> res; int v = ord_a; for (int p : ord.carmichael_prime_factors()) if (v % p == 0) { int& c = res.emplace_back(p, 0).second; do v /= p, ++c; while (v % p == 0); } return res; }(); std::vector<long long> rs, ms; for (auto [p, q] : ord_factorized) { int pq = 1; for (int i = 0; i < q; ++i) pq *= p; const int na = mint(a).pow(ord_a / pq).val(), nb = mint(b).pow(ord_a / pq).val(); const int x = pohlig_hellman_prime_power_bsgs(na, nb, pq, p, q); if (x == -1) return -1; rs.push_back(x), ms.push_back(pq); } return atcoder::crt(rs, ms).first; } } namespace internal { int discrete_logarithm_coprime(int a, int b) { const int m = mint::mod(); assert(std::gcd(a, m) == 1); long long r = 0, md = 1; for (auto [p, q] : fast_factorize::factorize(m)) { // CRT int pq = 1; for (int i = 0; i < q; ++i) pq *= p; mint::set_mod(pq); OrderMod ord(pq); const long long r2 = pohlig_hellman(mint(a).val(), mint(b).val(), p, q, ord); if (r2 == -1) return -1; const long long md2 = ord(a); std::tie(r, md) = atcoder::crt({ r, r2 }, { md, md2 }); if (md == 0) return -1; } return r; } int discrete_logarithm_arbitrary_mod(int a, int b) { const int m = mint::mod(); if (m == 1 or b == 1) return 0; if (a == 0) return b == 0 ? 1 : b == 1 ? 0 : -1; if (a == 1) return b == 1 ? 0 : -1; const int floor_log2_m = [m] { int res = 0; while (1 << (res + 1) <= m) ++res; return res; }(); if (int i = naive(a, b, floor_log2_m); i != -1) return i; const int pow_a = mint(a).pow(floor_log2_m).val(); const int g = std::gcd(pow_a, m); if (b % g) return -1; mint::set_mod(m / g); const int t = discrete_logarithm_coprime(mint(a).val(), (mint(b) / pow_a).val()); return t != -1 ? floor_log2_m + t : -1; } } int discrete_logarithm(int a, int b, int m) { using internal::mint; const int old_mod = mint::mod(); mint::set_mod(m); const int res = internal::discrete_logarithm_arbitrary_mod(mint(a).val(), mint(b).val()); mint::set_mod(old_mod); return res; } } // namespace suisen