#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
#define int __int128
#define LOCAL
namespace ly {
	namespace IO {
#ifndef LOCAL
		constexpr auto maxn = 1 << 20;
		char in[maxn], out[maxn], *p1 = in, *p2 = in, *p3 = out;
#define getchar() (p1 == p2 && (p2 = (p1 = in) + fread(in, 1, maxn, stdin), p1 == p2) ? EOF : *p1++)
#define flush() (fwrite(out, 1, p3-out, stdout))
#define putchar(x) (p3 == out + maxn && (flush(), p3 = out), *p3++ = (x))
		class Flush {
			public :
				~Flush() {
					flush();
				}
		} _;
#endif
		namespace usr {
			template <typename type>
			inline type read(type &x) {
				x = 0;
				bool flag(0);
				char ch = getchar();
				while(!isdigit(ch)) flag ^= ch == '-', ch = getchar();
				while(isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
				return flag ? x = -x : x;
			}
			template<typename type>
			inline void write(type x) {
				x < 0 ? x = -x, putchar('-') : 0;
				static short Stack[50], top(0);
				do Stack[++top] = x % 10, x /= 10;
				while(x);
				while(top) putchar(Stack[top--] | 48);
			}
			inline char read(char &x) {
				do x = getchar();
				while(isspace(x));
				return x;
			}
			inline char write(const char &x) {
				return putchar(x);
			}
			inline void read(char *x) {
				static char ch;
				read(ch);
				do *(x++) = ch;
				while(!isspace(ch = getchar()) && ~ch);
			}
			template <typename type>
			inline void write(type *x) {
				while(*x) putchar(*(x++));
			}
			inline void read(string &x) {
				static char ch;
				read(ch), x.clear();
				do x += ch;
				while(!isspace(ch = getchar()) && ~ch);
			}
			inline void write(const string &x) {
				for(int i = 0, len = x.length(); i < len; ++i) putchar(x[i]);
			}
			template <typename type, typename...T>
			inline void read(type &x, T&...y) {
				read(x), read(y...);
			}
			template <typename type, typename...T>
			inline void write(const type &x, const T&...y) {
				write(x), putchar(' '), write(y...), sizeof...(y) ^ 1 ? 0 : putchar('\n');
			}
			template <typename type>
			inline void put(const type &x, bool flag = 1) {
				write(x), flag ? putchar('\n') : putchar(' ');
			}
		}
#ifndef LOCAL
#undef getchar
#undef flush
#undef putchar
#endif
	}
	using namespace IO :: usr;
}
using namespace ly :: IO :: usr;
typedef std::vector<int> Poly;
inline int pow_mod(int b, int e, int n) {
	int res = 1;
	b = b % n;
	while (e > 0) {
		if (e % 2 == 1) {
			res = (res * b) % n;
		}
		e = e >> 1;
		b = (b * b) % n;
	}
	return res;
}
inline int inv(int a, int n) {
	return pow_mod(a, n - 2, n);
}
inline void ntt(Poly& a, int n, int g, bool inverse) {
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < i; ++j) {
			if (i < j) {
				int g_pow = inverse ? inv(pow_mod(g, i - j, n), n) : pow_mod(g, i - j, n);
				std::swap(a[i], a[j]);
				a[i] = (a[i] + a[j]) % n;
			} else if (i == j) {
				break;
			}
		}
	}
}
inline Poly multiply(Poly& a, Poly& b, int n, int g) {
	Poly c(n, 0);
	a.resize(n);
	b.resize(n);
	for (int i = 0; i < a.size(); ++i) {
		a[i] = a[i % a.size()];
	}
	for (int i = 0; i < b.size(); ++i) {
		b[i] = b[i % b.size()];
	}
	ntt(a, n, g, false);
	ntt(b, n, g, false);
	for (int i = 0; i < n; ++i) {
		c[i] = (a[i] * b[i]) % n;
	}
	ntt(c, n, g, true);
	for (int i = 0; i < n; ++i) {
		c[i] = (c[i] * inv(n, n)) % n;
	}
	return std::vector<int>(c.begin(), c.begin() + a.size() + b.size() - 1);
}


inline int phi(int x) {
	int ans = 1, num = 1;
	for(int i = 2; i * i <= x; i++) {
		if(!(x % i)) {
			num = i - 1, x /= i;
			while(!(x % i)) num *= i, x /= i;
			ans *= num;
		}
	}
	if(x != 1) ans *= (x - 1);
	return ans;
}
inline int gcd(int a, int b) {
	if(a == 0)return b;
	if(b == 0)return a;
	if(!(a & 1) && !(b & 1))return gcd(a >> 1, b >> 1) << 1;
	else if(!(b & 1))return gcd(a, b >> 1);
	else if(!(a & 1))return gcd(a >> 1, b);
	else return gcd(max(a, b) - min(a, b), std::min(a, b));
}
inline int fastPower(int base, int exp, int mod) {
	int result = 1;
	base = base % mod;
	while (exp > 0) {
		if (exp % 2 == 1) {
			result = (result * base) % mod;
		}
		exp = exp >> 1;
		base = (base * base) % mod;
	}
	return result;
}
inline bool isPrime(int n) {
	if (n <= 1) return false;
	if (n <= 3) return true;
	if (n % 2 == 0 || n % 3 == 0) return false;

	int d = n - 1;
	while (d % 2 == 0) {
		d /= 2;
	}

	Poly x(2, 1), y(2, 1);
	y[1] = d;

	Poly powers(n, 0);
	int power = d;
	for (int i = 0; i < n; ++i) {
		powers[i] = fastPower(2, power, n);
		power = (power * 2) % (n - 1);
	}

	for (int i = 0; i < n; ++i) {
		if (i % 2 == 0) {
			y = multiply(x, y, n, max(x.size(), y.size()));
		} else {
			x = multiply(x, x, n, x.size());
		}
		if (y[0] == 0) return false;
	}

	return (x[0] == 1);
}

signed main() {
	int number;
	read(number);
	if (isPrime(number)) {
		write(number, "is a prime number.");
	} else {
		write(number, "is not a prime number.");
	}
	return 0;
}