結果
| 問題 | No.2365 Present of good number |
| ユーザー |
 suisen
|
| 提出日時 | 2023-06-30 23:08:18 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
RE
|
| 実行時間 | - |
| コード長 | 37,304 bytes |
| コンパイル時間 | 3,261 ms |
| コンパイル使用メモリ | 329,484 KB |
| 実行使用メモリ | 6,948 KB |
| 最終ジャッジ日時 | 2024-07-07 11:03:37 |
| 合計ジャッジ時間 | 7,581 ms |
|
ジャッジサーバーID （参考情報） |
judge3 / judge1 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
5,248 KB |
| testcase_01 | AC | 2 ms
5,248 KB |
| testcase_02 | RE | - |
| testcase_03 | RE | - |
| testcase_04 | RE | - |
| testcase_05 | RE | - |
| testcase_06 | RE | - |
| testcase_07 | RE | - |
| testcase_08 | RE | - |
| testcase_09 | RE | - |
| testcase_10 | RE | - |
| testcase_11 | RE | - |
| testcase_12 | RE | - |
| testcase_13 | RE | - |
| testcase_14 | RE | - |
| testcase_15 | RE | - |
| testcase_16 | AC | 3 ms
5,376 KB |
| testcase_17 | AC | 2 ms
5,376 KB |
| testcase_18 | AC | 3 ms
5,376 KB |
| testcase_19 | AC | 2 ms
5,376 KB |
| testcase_20 | AC | 3 ms
5,376 KB |
| testcase_21 | AC | 2 ms
5,376 KB |
| testcase_22 | RE | - |
| testcase_23 | RE | - |
| testcase_24 | AC | 2 ms
5,376 KB |
| testcase_25 | RE | - |
| testcase_26 | RE | - |
| testcase_27 | RE | - |
| testcase_28 | RE | - |
| testcase_29 | RE | - |
| testcase_30 | RE | - |
| testcase_31 | WA | - |
| testcase_32 | WA | - |
| testcase_33 | WA | - |
| testcase_34 | WA | - |
| testcase_35 | WA | - |
| testcase_36 | RE | - |
| testcase_37 | RE | - |
| testcase_38 | RE | - |
| testcase_39 | RE | - |
| testcase_40 | RE | - |
ソースコード
#include <bits/stdc++.h>
#ifdef _MSC_VER
# include <intrin.h>
#else
# include <x86intrin.h>
#endif
#include <limits>
#include <type_traits>
namespace suisen {
// ! utility
template <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);
}
}
// ! function
template <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>;
// ! integral
template <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 aliases
using 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_t
std::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_t
std::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;
}
// pair
template <typename T, typename U>
std::ostream& operator<<(std::ostream& out, const std::pair<T, U>& a) {
return out << a.first << ' ' << a.second;
}
// tuple
template <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);
}
}
// vector
template <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;
}
// array
template <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_t
std::istream& operator>>(std::istream& in, __int128_t& v) {
std::string s;
in >> s;
v = stoi128(s);
return in;
}
// __uint128_t
std::istream& operator>>(std::istream& in, __uint128_t& v) {
std::string s;
in >> s;
v = stou128(s);
return in;
}
// pair
template <typename T, typename U>
std::istream& operator>>(std::istream& in, std::pair<T, U>& a) {
return in >> a.first >> a.second;
}
// tuple
template <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);
}
// vector
template <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;
}
// array
template <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; }
// ! container
template <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::sieve
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
constexpr 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_operator
namespace 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 suisen
namespace 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 atcoder
using 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()));
}