#pragma region opt #pragma GCC target("avx2") #pragma GCC optimize("O3") #pragma endregion opt #pragma region header #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #pragma endregion header #pragma region type /* signed integer */ typedef int8_t i8; typedef int16_t i16; typedef int32_t i32; typedef int64_t i64; typedef __int128_t i128; /* unsigned integer */ typedef uint8_t u8; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef __uint128_t u128; /* floating point number */ typedef float f32; typedef double f64; typedef long double f80; #pragma endregion type #pragma region macro #define MIN(a, b) (((a) < (b)) ? (a) : (b)) #define MAX(a, b) (((a) > (b)) ? (a) : (b)) #define SWAP(a, b) (((a) ^= (b)), ((b) ^= (a)), ((a) ^= (b))) #define POPCNT32(a) __builtin_popcount((a)) #define POPCNT64(a) __builtin_popcountll((a)) #define CTZ32(a) __builtin_ctz((a)) #define CLZ32(a) __builtin_clz((a)) #define CTZ64(a) __builtin_ctzll((a)) #define CLZ64(a) __builtin_clzll((a)) #define HAS_SINGLE_BIT32(a) (__builtin_popcount((a)) == (1)) #define HAS_SINGLE_BIT64(a) (__builtin_popcountll((a)) == (1)) #define MSB32(a) ((31) - __builtin_clz((a))) #define MSB64(a) ((63) - __builtin_clzll((a))) #define BIT_WIDTH32(a) ((a) ? ((32) - __builtin_clz((a))) : (0)) #define BIT_WIDTH64(a) ((a) ? ((64) - __builtin_clzll((a))) : (0)) #define LSBit(a) ((a) & (-(a))) #define CLSBit(a) ((a) & ((a) - (1))) #define BIT_CEIL32(a) ((!(a)) ? (1) : ((POPCNT32(a)) == (1) ? ((1u) << ((31) - CLZ32((a)))) : ((1u) << ((32) - CLZ32(a))))) #define BIT_CEIL64(a) ((!(a)) ? (1) : ((POPCNT64(a)) == (1) ? ((1ull) << ((63) - CLZ64((a)))) : ((1ull) << ((64) - CLZ64(a))))) #define BIT_FLOOR32(a) ((!(a)) ? (0) : ((1u) << ((31) - CLZ32((a))))) #define BIT_FLOOR64(a) ((!(a)) ? (0) : ((1ull) << ((63) - CLZ64((a))))) #define _ROTL32(x, s) (((x) << ((s) % (32))) | (((x) >> ((32) - ((s) % (32)))))) #define _ROTR32(x, s) (((x) >> ((s) % (32))) | (((x) << ((32) - ((s) % (32)))))) #define ROTL32(x, s) (((s) == (0)) ? (x) : ((((i64)(s)) < (0)) ? (_ROTR32((x), -(s))) : (_ROTL32((x), (s))))) #define ROTR32(x, s) (((s) == (0)) ? (x) : ((((i64)(s)) < (0)) ? (_ROTL32((x), -(s))) : (_ROTR32((x), (s))))) #define _ROTL64(x, s) (((x) << ((s) % (64))) | (((x) >> ((64) - ((s) % (64)))))) #define _ROTR64(x, s) (((x) >> ((s) % (64))) | (((x) << ((64) - ((s) % (64)))))) #define ROTL64(x, s) (((s) == (0)) ? (x) : ((((i128)(s)) < (0)) ? (_ROTR64((x), -(s))) : (_ROTL64((x), (s))))) #define ROTR64(x, s) (((s) == (0)) ? (x) : ((((i128)(s)) < (0)) ? (_ROTL64((x), -(s))) : (_ROTR64((x), (s))))) #pragma endregion macro #pragma region io int read_int(void) { // -2147483648 ~ 2147483647 (> 10 ^ 9) int c, x = 0, f = 1; while (c = getchar_unlocked(), c < 48 || c > 57) if (c == 45) f = -f; while (47 < c && c < 58) { x = x * 10 + c - 48; c = getchar_unlocked(); } return f * x; } i32 in_i32(void) { // -2147483648 ~ 2147483647 (> 10 ^ 9) i32 c, x = 0, f = 1; while (c = getchar_unlocked(), c < 48 || c > 57) if (c == 45) f = -f; while (47 < c && c < 58) { x = x * 10 + c - 48; c = getchar_unlocked(); } return f * x; } u32 in_u32(void) { // 0 ~ 4294967295 (> 10 ^ 9) u32 c, x = 0; while (c = getchar_unlocked(), c < 48 || c > 57); while (47 < c && c < 58) { x = x * 10 + c - 48; c = getchar_unlocked(); } return x; } i64 in_i64(void) { // -9223372036854775808 ~ 9223372036854775807 (> 10 ^ 18) i64 c, x = 0, f = 1; while (c = getchar_unlocked(), c < 48 || c > 57) if (c == 45) f = -f; while (47 < c && c < 58) { x = x * 10 + c - 48; c = getchar_unlocked(); } return f * x; } u64 in_u64(void) { // 0 ~ 18446744073709551615 (> 10 ^ 19) u64 c, x = 0; while (c = getchar_unlocked(), c < 48 || c > 57); while (47 < c && c < 58) { x = x * 10 + c - 48; c = getchar_unlocked(); } return x; } static inline void write_int_inner(int x) { if (x >= 10) write_int_inner(x / 10); putchar_unlocked(x - x / 10 * 10 + 48); } void write_int(int x) { if (x < 0) { putchar_unlocked('-'); x = -x; } write_int_inner(x); } static inline void out_i32_inner(i32 x) { if (x >= 10) out_i32_inner(x / 10); putchar_unlocked(x - x / 10 * 10 + 48); } void out_i32(i32 x) { if (x < 0) { putchar_unlocked('-'); x = -x; } out_i32_inner(x); } void out_u32(u32 x) { if (x >= 10) out_u32(x / 10); putchar_unlocked(x - x / 10 * 10 + 48); } static inline void out_i64_inner(i64 x) { if (x >= 10) out_i64_inner(x / 10); putchar_unlocked(x - x / 10 * 10 + 48); } void out_i64(i64 x) { if (x < 0) { putchar_unlocked('-'); x = -x; } out_i64_inner(x); } void out_u64(u64 x) { if (x >= 10) out_u64(x / 10); putchar_unlocked(x - x / 10 * 10 + 48); } void NL(void) { putchar_unlocked('\n'); } void SP(void) { putchar_unlocked(' '); } void write_int_array(int *a, int a_len) { for (int i = 0; i < a_len; i++) { if (i) SP(); write_int(a[i]); } NL(); } void out_i32_array(i32 *a, int a_len) { for (int i = 0; i < a_len; i++) { if (i) SP(); out_i32(a[i]); } NL(); } void out_u32_array(u32 *a, int a_len) { for (int i = 0; i < a_len; i++) { if (i) SP(); out_u32(a[i]); } NL(); } void out_i64_array(i64 *a, int a_len) { for (int i = 0; i < a_len; i++) { if (i) SP(); out_i64(a[i]); } NL(); } void out_u64_array(u64 *a, int a_len) { for (int i = 0; i < a_len; i++) { if (i) SP(); out_u64(a[i]); } NL(); } #pragma endregion io #pragma region xorshift const f64 _R_ = 1.0 / 0xffffffffffffffff; static u64 _xorshift_state_ = 88172645463325252ULL; u64 next_rand_xorshift(void) { _xorshift_state_ = _xorshift_state_ ^ (_xorshift_state_ << 7); return _xorshift_state_ = _xorshift_state_ ^ (_xorshift_state_ >> 9); } void rand_init_xorshift(u64 seed) { _xorshift_state_ += seed; (void)next_rand_xorshift(); } u64 random_range_xorshift(u64 l, u64 r) { return next_rand_xorshift() % (r - l + 1) + l; } f64 probability_xorshift(void) { return _R_ * next_rand_xorshift(); } #pragma endregion xorshift #pragma region binary gcd u32 bin_gcd_u32(u32 a, u32 b) { if (!a || !b) return a | b; u32 shift = CTZ32(a | b); a >>= CTZ32(a); do { b >>= CTZ32(b); if (a > b) SWAP(a, b); b -= a; } while (b); return a << shift; } u64 bin_gcd_u64(u64 a, u64 b) { if (!a || !b) return a | b; u64 shift = CTZ64(a | b); a >>= CTZ64(a); do { b >>= CTZ64(b); if (a > b) SWAP(a, b); b -= a; } while (b); return a << shift; } u64 bin_lcm_u64(u32 a, u32 b) { return (u64)a / bin_gcd_u32(a, b) * b; } #pragma endregion binary gcd #pragma region m32 typedef uint32_t m32; m32 _one_m32(u32 mod) { return (u32)-1u % mod + 1; } m32 _r2_m32(u32 mod) { return (u64)(i64)-1 % mod + 1; } m32 _inv_m32(u32 mod) { u32 inv = mod; for (int i = 0; i < 4; ++i) inv *= 2 - inv * mod; return inv; /** u32 u = 1, v = 0, x = 1u << 31; for (int i = 0; i < 32; i++) { if (u & 1) u = (u + mod) >> 1, v = (v >> 1) + x; else u >>= 1, v >>= 1; } return -v; */ } m32 _reduce_m32(u64 a, m32 inv, u32 mod) { u32 y = (u32)(a >> 32) - (u32)(((u64)((u32)a * inv) * mod) >> 32); return (i32)y < 0 ? y + mod : y; } m32 to_m32(u32 a, m32 r2, m32 inv, u32 mod) { return _reduce_m32((u64)a * r2, inv, mod); } u32 from_m32(m32 A, m32 inv, u32 mod) { return _reduce_m32(A, inv, mod); } m32 add_m32(m32 A, m32 B, u32 mod) { A += B - mod; if ((i32)A < 0) A += mod; return A; } m32 sub_m32(m32 A, m32 B, u32 mod) { if ((i32)(A -= B) < 0) A += 2 * mod; return A; } m32 min_m32(m32 A, u32 mod) { return sub_m32(0u, A, mod); } m32 mul_m32(m32 A, m32 B, m32 inv, u32 mod) { return _reduce_m32((u64)A * B, inv, mod); } m32 pow_m32(m32 A, i32 n, m32 inv, u32 mod) { m32 ret = _one_m32(mod); while (n > 0) { if (n & 1) ret = mul_m32(ret, A, inv, mod); A = mul_m32(A, A, inv, mod); n >>= 1; } return ret; } m32 inv_m32(m32 A, m32 inv, u32 mod) { return pow_m32(A, (i32)mod - 2, inv, mod); } m32 div_m32(m32 A, m32 B, m32 inv, u32 mod) { /* assert(is_prime(mod)); */ return mul_m32(A, inv_m32(B, inv, mod), inv, mod); } m32 in_m32(m32 r2, m32 inv, u32 mod) { u32 c, a = 0; while (c = getchar_unlocked(), c < 48 || c > 57); while (47 < c && c < 58) { a = a * 10 + c - 48; c = getchar_unlocked(); } return to_m32(a, r2, inv, mod); } void out_m32(m32 A, m32 inv, u32 mod) { u32 a = from_m32(A, inv, mod); out_u32(a); } #pragma endregion m32 #pragma region m64 typedef uint64_t m64; m64 _one_m64(u64 mod) { return (u64)-1ull % mod + 1; } m64 _r2_m64(u64 mod) { return (u128)(i128)-1 % mod + 1; } m64 _inv_m64(u64 mod) { m64 inv = mod; for (int i = 0; i < 5; i++) inv *= 2 - inv * mod; return inv; } m64 _reduce_m64(u128 a, m64 inv, u64 mod) { u64 y = (u64)(a >> 64) - (u64)(((u128)((u64)a * inv) * mod) >> 64); return (i64)y < 0 ? y + mod : y; } m64 to_m64(u64 a, m64 r2, m64 inv, u64 mod) { return _reduce_m64((u128)a * r2, inv, mod); } u64 from_m64(m64 A, m64 inv, u64 mod) { return _reduce_m64(A, inv, mod); } m64 add_m64(m64 A, m64 B, u64 mod) { A += B - mod; if ((i64)A < 0) A += mod; return A; } m64 sub_m64(m64 A, m64 B, u64 mod) { if ((i64)(A -= B) < 0) A += 2 * mod; return A; } m64 min_m64(m64 A, u64 mod) { return sub_m64(0ull, A, mod); } m64 mul_m64(m64 A, m64 B, m64 inv, u64 mod) { return _reduce_m64((u128)A * B, inv, mod); } m64 pow_m64(m64 A, i64 n, m64 inv, u64 mod) { m64 ret = _one_m64(mod); while (n > 0) { if (n & 1) ret = mul_m64(ret, A, inv, mod); A = mul_m64(A, A, inv, mod); n >>= 1; } return ret; } m64 inv_m64(m64 A, m64 inv, u64 mod) { return pow_m64(A, (i64)mod - 2, inv, mod); } m64 div_m64(m64 A, m64 B, m64 inv, u64 mod) { /* assert(is_prime(mod)); */ return mul_m64(A, inv_m64(B, inv, mod), inv, mod); } m64 in_m64(m64 r2, m64 inv, u64 mod) { u64 c, a = 0; while (c = getchar_unlocked(), c < 48 || c > 57); while (47 < c && c < 58) { a = a * 10 + c - 48; c = getchar_unlocked(); } return to_m64(a, r2, inv, mod); } void out_m64(m64 A, m64 inv, u64 mod) { u64 a = from_m64(A, inv, mod); out_u64(a); } #pragma endregion m64 #pragma region quadratic_residue bool euler_criterion(u32 a, m32 r2, m32 inv, u32 mod) { return pow_m32(to_m32(a, r2, inv, mod), (mod - 1) >> 1, inv, mod) == _one_m32(mod); } int legendre_symbol(u32 a, m32 r2, m32 inv, u32 mod) { // assert(a >= 0 && mod & 1 && is_prime(mod)); int ret; if (_reduce_m32((u64)a, inv, mod) == 0) ret = 0; else if (euler_criterion(a, r2, inv, mod)) ret = 1; else ret = -1; return ret; } int jacobi_symbol(u64 k, u64 n) { // assert(n >= 0 && n & 1); u64 j = 1; while (k) { if ((i64)k < 0) { k = -k; if ((n & 3) == 3) j = -j; } int a = CTZ64(k); k >>= a; if (((n & 7) == 3 || (n & 7) == 5) && (a & 1)) j = -j; SWAP(k, n); if ((k & n & 3) == 3) j = -j; k %= n; if (k > n / 2) k -= n; } return n == 1 ? j : 0; } #pragma endregion quadratic_residue #pragma region solovay_strassen primary test bool solovay_strassen(u64 n) { if (n == 2 || n == 3 || n == 5 || n == 7) return true; if (!(n & 1)) return false; if (n % 3 == 0 || n % 5 == 0 || n % 7 == 0) return false; if (n < 121) return true; u64 mod = n; m64 r2 = _r2_m64(mod); m64 inv = _inv_m64(mod); for (int i = 0; i < 100; i++) { u64 a = random_range_xorshift(1, n - 1); if (1 < bin_gcd_u64(a, n)) return false; m64 A = to_m64(a, r2, inv, mod); if (jacobi_symbol(a, n) != pow_m64(A, (n - 1) >> 1, inv, mod)) return false; } return true; } #pragma endregion solovay_strassen primary test void Main(void) { int T = read_int(); while (T--) { u64 x = in_u64(); out_u64(x); SP(); write_int(solovay_strassen(x)); NL(); } } int main(void) { Main(); return 0; }