結果
| 問題 | No.2365 Present of good number |
| ユーザー |
 suisen
|
| 提出日時 | 2023-06-30 23:08:18 |
| 言語 | C++17 (gcc 13.3.0 + boost 1.87.0) |
| 結果 |
RE
|
| 実行時間 | - |
| コード長 | 37,304 bytes |
| コンパイル時間 | 3,364 ms |
| コンパイル使用メモリ | 330,056 KB |
| 最終ジャッジ日時 | 2025-02-15 04:34:48 |
|
ジャッジサーバーID （参考情報） |
judge2 / judge1 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 2 |
| other | AC * 7 WA * 5 RE * 27 |
ソースコード
#include <bits/stdc++.h>#ifdef _MSC_VER# include <intrin.h>#else# include <x86intrin.h>#endif#include <limits>#include <type_traits>namespace suisen {// ! utilitytemplate <typename ...Types>using constraints_t = std::enable_if_t<std::conjunction_v<Types...>, std::nullptr_t>;template <bool cond_v, typename Then, typename OrElse>constexpr decltype(auto) constexpr_if(Then&& then, OrElse&& or_else) {if constexpr (cond_v) {return std::forward<Then>(then);} else {return std::forward<OrElse>(or_else);}}// ! functiontemplate <typename ReturnType, typename Callable, typename ...Args>using is_same_as_invoke_result = std::is_same<std::invoke_result_t<Callable, Args...>, ReturnType>;template <typename F, typename T>using is_uni_op = is_same_as_invoke_result<T, F, T>;template <typename F, typename T>using is_bin_op = is_same_as_invoke_result<T, F, T, T>;template <typename Comparator, typename T>using is_comparator = std::is_same<std::invoke_result_t<Comparator, T, T>, bool>;// ! integraltemplate <typename T, typename = constraints_t<std::is_integral<T>>>constexpr int bit_num = std::numeric_limits<std::make_unsigned_t<T>>::digits;template <typename T, unsigned int n>struct is_nbit { static constexpr bool value = bit_num<T> == n; };template <typename T, unsigned int n>static constexpr bool is_nbit_v = is_nbit<T, n>::value;// ?template <typename T>struct safely_multipliable {};template <>struct safely_multipliable<int> { using type = long long; };template <>struct safely_multipliable<long long> { using type = __int128_t; };template <>struct safely_multipliable<unsigned int> { using type = unsigned long long; };template <>struct safely_multipliable<unsigned long int> { using type = __uint128_t; };template <>struct safely_multipliable<unsigned long long> { using type = __uint128_t; };template <>struct safely_multipliable<float> { using type = float; };template <>struct safely_multipliable<double> { using type = double; };template <>struct safely_multipliable<long double> { using type = long double; };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;} // namespace suisen// ! type aliasesusing i128 = __int128_t;using u128 = __uint128_t;template <typename T>using pq_greater = std::priority_queue<T, std::vector<T>, std::greater<T>>;// ! macros (internal)#define DETAIL_OVERLOAD2(_1,_2,name,...) name#define DETAIL_OVERLOAD3(_1,_2,_3,name,...) name#define DETAIL_OVERLOAD4(_1,_2,_3,_4,name,...) name#define DETAIL_REP4(i,l,r,s) for(std::remove_reference_t<std::remove_const_t<decltype(r)>>i=(l);i<(r);i+=(s))#define DETAIL_REP3(i,l,r) DETAIL_REP4(i,l,r,1)#define DETAIL_REP2(i,n) DETAIL_REP3(i,0,n)#define DETAIL_REPINF3(i,l,s) for(std::remove_reference_t<std::remove_const_t<decltype(l)>>i=(l);;i+=(s))#define DETAIL_REPINF2(i,l) DETAIL_REPINF3(i,l,1)#define DETAIL_REPINF1(i) DETAIL_REPINF2(i,0)#define DETAIL_RREP4(i,l,r,s) for(std::remove_reference_t<std::remove_const_t<decltype(r)>>i=(l)+fld((r)-(l)-1,s)*(s);i>=(l);i-=(s))#define DETAIL_RREP3(i,l,r) DETAIL_RREP4(i,l,r,1)#define DETAIL_RREP2(i,n) DETAIL_RREP3(i,0,n)#define DETAIL_CAT_I(a, b) a##b#define DETAIL_CAT(a, b) DETAIL_CAT_I(a, b)#define DETAIL_UNIQVAR(tag) DETAIL_CAT(tag, __LINE__)// ! macros#define REP(...) DETAIL_OVERLOAD4(__VA_ARGS__, DETAIL_REP4 , DETAIL_REP3 , DETAIL_REP2 )(__VA_ARGS__)#define RREP(...) DETAIL_OVERLOAD4(__VA_ARGS__, DETAIL_RREP4 , DETAIL_RREP3 , DETAIL_RREP2 )(__VA_ARGS__)#define REPINF(...) DETAIL_OVERLOAD3(__VA_ARGS__, DETAIL_REPINF3, DETAIL_REPINF2, DETAIL_REPINF1)(__VA_ARGS__)#define LOOP(n) for (std::remove_reference_t<std::remove_const_t<decltype(n)>> DETAIL_UNIQVAR(loop_variable) = n; DETAIL_UNIQVAR(loop_variable) --> 0;)#define ALL(iterable) std::begin(iterable), std::end(iterable)#define INPUT(type, ...) type __VA_ARGS__; read(__VA_ARGS__)// ! debug#ifdef LOCAL# define debug(...) debug_internal(#__VA_ARGS__, __VA_ARGS__)template <class T, class... Args>void debug_internal(const char* s, T&& first, Args&&... args) {constexpr const char* prefix = "[\033[32mDEBUG\033[m] ";constexpr const char* open_brakets = sizeof...(args) == 0 ? "" : "(";constexpr const char* close_brakets = sizeof...(args) == 0 ? "" : ")";std::cerr << prefix << open_brakets << s << close_brakets << ": " << open_brakets << std::forward<T>(first);((std::cerr << ", " << std::forward<Args>(args)), ...);std::cerr << close_brakets << "\n";}#else# define debug(...) void(0)#endif// ! I/O utilities// __int128_tstd::ostream& operator<<(std::ostream& dest, __int128_t value) {std::ostream::sentry s(dest);if (s) {__uint128_t tmp = value < 0 ? -value : value;char buffer[128];char* d = std::end(buffer);do {--d;*d = "0123456789"[tmp % 10];tmp /= 10;} while (tmp != 0);if (value < 0) {--d;*d = '-';}int len = std::end(buffer) - d;if (dest.rdbuf()->sputn(d, len) != len) {dest.setstate(std::ios_base::badbit);}}return dest;}// __uint128_tstd::ostream& operator<<(std::ostream& dest, __uint128_t value) {std::ostream::sentry s(dest);if (s) {char buffer[128];char* d = std::end(buffer);do {--d;*d = "0123456789"[value % 10];value /= 10;} while (value != 0);int len = std::end(buffer) - d;if (dest.rdbuf()->sputn(d, len) != len) {dest.setstate(std::ios_base::badbit);}}return dest;}// pairtemplate <typename T, typename U>std::ostream& operator<<(std::ostream& out, const std::pair<T, U>& a) {return out << a.first << ' ' << a.second;}// tupletemplate <unsigned int N = 0, typename ...Args>std::ostream& operator<<(std::ostream& out, const std::tuple<Args...>& a) {if constexpr (N >= std::tuple_size_v<std::tuple<Args...>>) return out;else {out << std::get<N>(a);if constexpr (N + 1 < std::tuple_size_v<std::tuple<Args...>>) out << ' ';return operator<<<N + 1>(out, a);}}// vectortemplate <typename T>std::ostream& operator<<(std::ostream& out, const std::vector<T>& a) {for (auto it = a.begin(); it != a.end();) {out << *it;if (++it != a.end()) out << ' ';}return out;}// arraytemplate <typename T, size_t N>std::ostream& operator<<(std::ostream& out, const std::array<T, N>& a) {for (auto it = a.begin(); it != a.end();) {out << *it;if (++it != a.end()) out << ' ';}return out;}inline void print() { std::cout << '\n'; }template <typename Head, typename... Tail>inline void print(const Head& head, const Tail &...tails) {std::cout << head;if (sizeof...(tails)) std::cout << ' ';print(tails...);}template <typename Iterable>auto print_all(const Iterable& v, std::string sep = " ", std::string end = "\n") -> decltype(std::cout << *v.begin(), void()) {for (auto it = v.begin(); it != v.end();) {std::cout << *it;if (++it != v.end()) std::cout << sep;}std::cout << end;}__int128_t stoi128(const std::string& s) {__int128_t ret = 0;for (int i = 0; i < int(s.size()); i++) if ('0' <= s[i] and s[i] <= '9') ret = 10 * ret + s[i] - '0';if (s[0] == '-') ret = -ret;return ret;}__uint128_t stou128(const std::string& s) {__uint128_t ret = 0;for (int i = 0; i < int(s.size()); i++) if ('0' <= s[i] and s[i] <= '9') ret = 10 * ret + s[i] - '0';return ret;}// __int128_tstd::istream& operator>>(std::istream& in, __int128_t& v) {std::string s;in >> s;v = stoi128(s);return in;}// __uint128_tstd::istream& operator>>(std::istream& in, __uint128_t& v) {std::string s;in >> s;v = stou128(s);return in;}// pairtemplate <typename T, typename U>std::istream& operator>>(std::istream& in, std::pair<T, U>& a) {return in >> a.first >> a.second;}// tupletemplate <unsigned int N = 0, typename ...Args>std::istream& operator>>(std::istream& in, std::tuple<Args...>& a) {if constexpr (N >= std::tuple_size_v<std::tuple<Args...>>) return in;else return operator>><N + 1>(in >> std::get<N>(a), a);}// vectortemplate <typename T>std::istream& operator>>(std::istream& in, std::vector<T>& a) {for (auto it = a.begin(); it != a.end(); ++it) in >> *it;return in;}// arraytemplate <typename T, size_t N>std::istream& operator>>(std::istream& in, std::array<T, N>& a) {for (auto it = a.begin(); it != a.end(); ++it) in >> *it;return in;}template <typename ...Args>void read(Args &...args) {(std::cin >> ... >> args);}// ! integral utilities// Returns pow(-1, n)template <typename T> constexpr inline int pow_m1(T n) {return -(n & 1) | 1;}// Returns pow(-1, n)template <> constexpr inline int pow_m1<bool>(bool n) {return -int(n) | 1;}// Returns floor(x / y)template <typename T> constexpr inline T fld(const T x, const T y) {return (x ^ y) >= 0 ? x / y : (x - (y + pow_m1(y >= 0))) / y;}template <typename T> constexpr inline T cld(const T x, const T y) {return (x ^ y) <= 0 ? x / y : (x + (y + pow_m1(y >= 0))) / y;}template <typename T, std::enable_if_t<std::negation_v<suisen::is_nbit<T, 64>>, std::nullptr_t> = nullptr>__attribute__((target("popcnt"))) constexpr inline int popcount(const T x) { return _mm_popcnt_u32(x); }template <typename T, std::enable_if_t<suisen::is_nbit_v<T, 64>, std::nullptr_t> = nullptr>__attribute__((target("popcnt"))) constexpr inline int popcount(const T x) { return _mm_popcnt_u64(x); }template <typename T, std::enable_if_t<std::negation_v<suisen::is_nbit<T, 64>>, std::nullptr_t> = nullptr>constexpr inline int count_lz(const T x) { return x ? __builtin_clz(x) : suisen::bit_num<T>; }template <typename T, std::enable_if_t<suisen::is_nbit_v<T, 64>, std::nullptr_t> = nullptr>constexpr inline int count_lz(const T x) { return x ? __builtin_clzll(x) : suisen::bit_num<T>; }template <typename T, std::enable_if_t<std::negation_v<suisen::is_nbit<T, 64>>, std::nullptr_t> = nullptr>constexpr inline int count_tz(const T x) { return x ? __builtin_ctz(x) : suisen::bit_num<T>; }template <typename T, std::enable_if_t<suisen::is_nbit_v<T, 64>, std::nullptr_t> = nullptr>constexpr inline int count_tz(const T x) { return x ? __builtin_ctzll(x) : suisen::bit_num<T>; }template <typename T> constexpr inline int floor_log2(const T x) { return suisen::bit_num<T> - 1 - count_lz(x); }template <typename T> constexpr inline int ceil_log2(const T x) { return floor_log2(x) + ((x & -x) != x); }template <typename T> constexpr inline int kth_bit(const T x, const unsigned int k) { return (x >> k) & 1; }template <typename T> constexpr inline int parity(const T x) { return popcount(x) & 1; }// ! containertemplate <typename T, typename Comparator>auto priqueue_comp(const Comparator comparator) {return std::priority_queue<T, std::vector<T>, Comparator>(comparator);}template <typename Container>void sort_unique_erase(Container& a) {std::sort(a.begin(), a.end());a.erase(std::unique(a.begin(), a.end()), a.end());}template <typename InputIterator, typename BiConsumer>auto foreach_adjacent_values(InputIterator first, InputIterator last, BiConsumer f) -> decltype(f(*first++, *last), void()) {if (first != last) for (auto itr = first, itl = itr++; itr != last; itl = itr++) f(*itl, *itr);}template <typename Container, typename BiConsumer>auto foreach_adjacent_values(Container &&c, BiConsumer f) -> decltype(c.begin(), c.end(), void()) {foreach_adjacent_values(c.begin(), c.end(), f);}// ! other utilities// x <- min(x, y). returns true iff `x` has chenged.template <typename T>inline bool chmin(T& x, const T& y) {return y >= x ? false : (x = y, true);}// x <- max(x, y). returns true iff `x` has chenged.template <typename T>inline bool chmax(T& x, const T& y) {return y <= x ? false : (x = y, true);}template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr>std::string bin(T val, int bit_num = -1) {std::string res;if (bit_num != -1) {for (int bit = bit_num; bit-- > 0;) res += '0' + ((val >> bit) & 1);} else {for (; val; val >>= 1) res += '0' + (val & 1);std::reverse(res.begin(), res.end());}return res;}template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr>std::vector<T> digits_low_to_high(T val, T base = 10) {std::vector<T> res;for (; val; val /= base) res.push_back(val % base);if (res.empty()) res.push_back(T{ 0 });return res;}template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr>std::vector<T> digits_high_to_low(T val, T base = 10) {auto res = digits_low_to_high(val, base);std::reverse(res.begin(), res.end());return res;}template <typename T>std::string join(const std::vector<T>& v, const std::string& sep, const std::string& end) {std::ostringstream ss;for (auto it = v.begin(); it != v.end();) {ss << *it;if (++it != v.end()) ss << sep;}ss << end;return ss.str();}template <typename Func, typename Seq>auto transform_to_vector(const Func &f, const Seq &s) {std::vector<std::invoke_result_t<Func, typename Seq::value_type>> v;v.reserve(std::size(s)), std::transform(std::begin(s), std::end(s), std::back_inserter(v), f);return v;}template <typename T, typename Seq>auto copy_to_vector(const Seq &s) {std::vector<T> v;v.reserve(std::size(s)), std::copy(std::begin(s), std::end(s), std::back_inserter(v));return v;}template <typename Seq>Seq concat(Seq s, const Seq &t) {s.reserve(std::size(s) + std::size(t));std::copy(std::begin(t), std::end(t), std::back_inserter(s));return s;}template <typename Seq>std::vector<Seq> split(const Seq s, typename Seq::value_type delim) {std::vector<Seq> res;for (auto itl = std::begin(s), itr = itl;; itl = ++itr) {while (itr != std::end(s) and *itr != delim) ++itr;res.emplace_back(itl, itr);if (itr == std::end(s)) return res;}}int digit_to_int(char c) { return c - '0'; }int lowercase_to_int(char c) { return c - 'a'; }int uppercase_to_int(char c) { return c - 'A'; }std::vector<int> digit_str_to_ints(const std::string &s) {return transform_to_vector(digit_to_int, s);}std::vector<int> lowercase_str_to_ints(const std::string &s) {return transform_to_vector(lowercase_to_int, s);}std::vector<int> uppercase_str_to_ints(const std::string &s) {return transform_to_vector(uppercase_to_int, s);}template <typename T, typename ToKey, typename CompareValue = std::less<>,std::enable_if_t<std::conjunction_v<std::is_invocable<ToKey, T>,std::is_invocable_r<bool, CompareValue, std::invoke_result_t<ToKey, T>, std::invoke_result_t<ToKey, T>>>, std::nullptr_t> = nullptr>auto comparator(const ToKey &to_key, const CompareValue &compare_value = std::less<>()) {return [to_key, compare_value](const T& x, const T& y) { return compare_value(to_key(x), to_key(y)); };}template <typename ToKey, std::enable_if_t<std::is_invocable_v<ToKey, int>, std::nullptr_t> = nullptr>std::vector<int> sorted_indices(int n, const ToKey &to_key) {std::vector<int> p(n);std::iota(p.begin(), p.end(), 0);std::sort(p.begin(), p.end(), comparator<int>(to_key));return p;}template <typename Compare, std::enable_if_t<std::is_invocable_r_v<bool, Compare, int, int>, std::nullptr_t> = nullptr>std::vector<int> sorted_indices(int n, const Compare &compare) {std::vector<int> p(n);std::iota(p.begin(), p.end(), 0);std::sort(p.begin(), p.end(), compare);return p;}const std::string Yes = "Yes", No = "No", YES = "YES", NO = "NO";namespace suisen {}using namespace suisen;using namespace std;struct io_setup {io_setup(int precision = 20) {std::ios::sync_with_stdio(false);std::cin.tie(nullptr);std::cout << std::fixed << std::setprecision(precision);}} io_setup_ {};// ! code from here#include <cassert>#include <cmath>#include <vector>#include <cstdint>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::sievenamespace 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 suisenconstexpr int N = 10010;#include <array>#include <optional>namespace suisen {namespace default_operator {template <typename T>auto zero() -> decltype(T { 0 }) { return T { 0 }; }template <typename T>auto one() -> decltype(T { 1 }) { return T { 1 }; }template <typename T>auto add(const T &x, const T &y) -> decltype(x + y) { return x + y; }template <typename T>auto sub(const T &x, const T &y) -> decltype(x - y) { return x - y; }template <typename T>auto mul(const T &x, const T &y) -> decltype(x * y) { return x * y; }template <typename T>auto div(const T &x, const T &y) -> decltype(x / y) { return x / y; }template <typename T>auto mod(const T &x, const T &y) -> decltype(x % y) { return x % y; }template <typename T>auto neg(const T &x) -> decltype(-x) { return -x; }template <typename T>auto inv(const T &x) -> decltype(one<T>() / x) { return one<T>() / x; }} // default_operatornamespace default_operator_noref {template <typename T>auto zero() -> decltype(T { 0 }) { return T { 0 }; }template <typename T>auto one() -> decltype(T { 1 }) { return T { 1 }; }template <typename T>auto add(T x, T y) -> decltype(x + y) { return x + y; }template <typename T>auto sub(T x, T y) -> decltype(x - y) { return x - y; }template <typename T>auto mul(T x, T y) -> decltype(x * y) { return x * y; }template <typename T>auto div(T x, T y) -> decltype(x / y) { return x / y; }template <typename T>auto mod(T x, T y) -> decltype(x % y) { return x % y; }template <typename T>auto neg(T x) -> decltype(-x) { return -x; }template <typename T>auto inv(T x) -> decltype(one<T>() / x) { return one<T>() / x; }} // default_operator} // namespace suisennamespace suisen {template <typename T, size_t N, size_t M,T(*_add)(T, T) = default_operator_noref::add<T>, T(*_neg)(T) = default_operator_noref::neg<T>, T(*_zero)() = default_operator_noref::zero<T>,T(*_mul)(T, T) = default_operator_noref::mul<T>, T(*_inv)(T) = default_operator_noref::inv<T>, T(*_one)() = default_operator_noref::one<T>>struct ArrayMatrix : public std::array<std::array<T, M>, N> {private:template <typename DummyType = void>static constexpr bool is_square_v = N == M;template <size_t X, size_t Y>using MatrixType = ArrayMatrix<T, X, Y, _add, _neg, _zero, _mul, _inv, _one>;public:using base_type = std::array<std::array<T, M>, N>;using container_type = base_type;using row_type = std::array<T, M>;using base_type::base_type;ArrayMatrix(T diag_val = _zero()) {for (size_t i = 0; i < N; ++i) for (size_t j = 0; j < M; ++j) {(*this)[i][j] = (i == j ? diag_val : _zero());}}ArrayMatrix(const container_type& c) : base_type{ c } {}ArrayMatrix(const std::initializer_list<row_type>& c) {assert(c.size() == N);size_t i = 0;for (const auto& row : c) {for (size_t j = 0; j < M; ++j) (*this)[i][j] = row[j];++i;}}static ArrayMatrix e0() { return ArrayMatrix(_zero()); }static MatrixType<M, M> e1() { return MatrixType<M, M>(_one()); }int size() const {static_assert(is_square_v<>);return N;}std::pair<int, int> shape() const { return { N, M }; }int row_size() const { return N; }int col_size() const { return M; }ArrayMatrix operator+() const { return *this; }ArrayMatrix operator-() const {ArrayMatrix A;for (size_t i = 0; i < N; ++i) for (size_t j = 0; j < M; ++j) A[i][j] = _neg((*this)[i][j]);return A;}friend ArrayMatrix& operator+=(ArrayMatrix& A, const ArrayMatrix& B) {for (size_t i = 0; i < N; ++i) for (size_t j = 0; j < M; ++j) A[i][j] = _add(A[i][j], B[i][j]);return A;}friend ArrayMatrix& operator-=(ArrayMatrix& A, const ArrayMatrix& B) {for (size_t i = 0; i < N; ++i) for (size_t j = 0; j < M; ++j) A[i][j] = _add(A[i][j], _neg(B[i][j]));return A;}template <size_t K>friend MatrixType<N, K>& operator*=(ArrayMatrix& A, const MatrixType<M, K>& B) { return A = A * B; }friend ArrayMatrix& operator*=(ArrayMatrix& A, const T& val) {for (size_t i = 0; i < N; ++i) for (size_t j = 0; j < M; ++j) A[i][j] = _mul(A[i][j], val);return A;}friend ArrayMatrix& operator/=(ArrayMatrix& A, const ArrayMatrix& B) { static_assert(is_square_v<>); return A *= *B.inv(); }friend ArrayMatrix& operator/=(ArrayMatrix& A, const T& val) { return A *= _inv(val); }friend ArrayMatrix operator+(ArrayMatrix A, const ArrayMatrix& B) { A += B; return A; }friend ArrayMatrix operator-(ArrayMatrix A, const ArrayMatrix& B) { A -= B; return A; }template <size_t K>friend MatrixType<N, K> operator*(const ArrayMatrix& A, const MatrixType<M, K>& B) {MatrixType<N, K> C;for (size_t i = 0; i < N; ++i) {C[i].fill(_zero());for (size_t j = 0; j < M; ++j) for (size_t k = 0; k < K; ++k) C[i][k] = _add(C[i][k], _mul(A[i][j], B[j][k]));}return C;}friend ArrayMatrix operator*(ArrayMatrix A, const T& val) { A *= val; return A; }friend ArrayMatrix operator*(const T& val, ArrayMatrix A) {for (size_t i = 0; i < N; ++i) for (size_t j = 0; j < M; ++j) A[i][j] = _mul(val, A[i][j]);return A;}friend std::array<T, N> operator*(const ArrayMatrix& A, const std::array<T, M>& x) {std::array<T, N> b;b.fill(_zero());for (size_t i = 0; i < N; ++i) for (size_t j = 0; j < M; ++j) b[i] = _add(b[i], _mul(A[i][j], x[j]));return b;}friend ArrayMatrix operator/(ArrayMatrix A, const ArrayMatrix& B) { static_assert(is_square_v<>); return A * B.inv(); }friend ArrayMatrix operator/(ArrayMatrix A, const T& val) { A /= val; return A; }friend ArrayMatrix operator/(const T& val, ArrayMatrix A) { return A.inv() *= val; }ArrayMatrix pow(long long b) const {static_assert(is_square_v<>);assert(b >= 0);ArrayMatrix res(e1()), p(*this);for (; b; b >>= 1) {if (b & 1) res *= p;p *= p;}return res;}std::optional<ArrayMatrix> safe_inv() const {static_assert(is_square_v<>);std::array<std::array<T, 2 * N>, N> data;for (size_t i = 0; i < N; ++i) {for (size_t j = 0; j < N; ++j) {data[i][j] = (*this)[i][j];data[i][N + j] = i == j ? _one() : _zero();}}for (size_t i = 0; i < N; ++i) {for (size_t k = i; k < N; ++k) if (data[k][i] != _zero()) {data[i].swap(data[k]);T c = _inv(data[i][i]);for (size_t j = i; j < 2 * N; ++j) data[i][j] = _mul(c, data[i][j]);break;}if (data[i][i] == _zero()) return std::nullopt;for (size_t k = 0; k < N; ++k) if (k != i and data[k][i] != _zero()) {T c = data[k][i];for (size_t j = i; j < 2 * N; ++j) data[k][j] = _add(data[k][j], _neg(_mul(c, data[i][j])));}}ArrayMatrix res;for (size_t i = 0; i < N; ++i) std::copy(data[i].begin() + N, data[i].begin() + 2 * N, res[i].begin());return res;}ArrayMatrix inv() const { return *safe_inv(); }T det() const {static_assert(is_square_v<>);ArrayMatrix A = *this;bool sgn = false;for (size_t j = 0; j < N; ++j) for (size_t i = j + 1; i < N; ++i) if (A[i][j] != _zero()) {std::swap(A[j], A[i]);T q = _mul(A[i][j], _inv(A[j][j]));for (size_t k = j; k < N; ++k) A[i][k] = _add(A[i][k], _neg(_mul(A[j][k], q)));sgn = not sgn;}T res = sgn ? _neg(_one()) : _one();for (size_t i = 0; i < N; ++i) res = _mul(res, A[i][i]);return res;}T det_arbitrary_mod() const {static_assert(is_square_v<>);ArrayMatrix A = *this;bool sgn = false;for (size_t j = 0; j < N; ++j) for (size_t i = j + 1; i < N; ++i) {for (; A[i][j].val(); sgn = not sgn) {std::swap(A[j], A[i]);T q = A[i][j].val() / A[j][j].val();for (size_t k = j; k < N; ++k) A[i][k] -= A[j][k] * q;}}T res = sgn ? -1 : +1;for (size_t i = 0; i < N; ++i) res *= A[i][i];return res;}};template <typename T, size_t N,T(*_add)(T, T) = default_operator_noref::add<T>, T(*_neg)(T) = default_operator_noref::neg<T>, T(*_zero)() = default_operator_noref::zero<T>,T(*_mul)(T, T) = default_operator_noref::mul<T>, T(*_inv)(T) = default_operator_noref::inv<T>, T(*_one)() = default_operator_noref::one<T>>using SquareArrayMatrix = ArrayMatrix<T, N, N, _add, _neg, _zero, _mul, _inv, _one>;} // namespace suisen#include <atcoder/modint>using mint = atcoder::modint1000000007;namespace atcoder {std::istream& operator>>(std::istream& in, mint &a) {long long e; in >> e; a = e;return in;}std::ostream& operator<<(std::ostream& out, const mint &a) {out << a.val();return out;}} // namespace atcoderusing mint2 = atcoder::static_modint<mint::mod() - 1>;int main() {int n;long long k;read(n, k);Sieve<N> sieve;vector<vector<pair<int, int>>> g(N);REP(i, 2, N) if (sieve.is_prime(i)) {for (auto [p, q] : sieve.factorize(i + 1)) {g[i].emplace_back(p, q);}}map<int, mint2> mp;for (auto [p, q] : sieve.factorize(n)) {mp[p] += q;}int t = min<int>(k, 20);LOOP(t) {map<int, mint2> nmp;for (auto [p, q] : mp) {for (auto [np, c] : g[p]) {nmp[np] += q * c;}}mp.swap(nmp);}k -= t;if (k == 0) {mint ans = 1;for (auto [p, q] : mp) {ans *= mint(p).pow(q.val());}print(ans);return 0;}mint2 c2 = mp[2];mint2 c3 = mp[3];SquareArrayMatrix<mint2, 2> A {{ 0, 2 },{ 1, 0 }};auto [nc2, nc3] = A.pow(k) * array<mint2, 2>{ c2, c3 };c2 = nc2;c3 = nc3;print(mint(2).pow(c2.val()) * mint(3).pow(c3.val()));}