#include <algorithm>
#include <cassert>
#include <vector>

namespace exodus{
	typedef long long ll;
	typedef unsigned long long ull;
	typedef unsigned int uint;
	template<typename U>
	int qpow(int x,U n,int mod){
		if(mod==1)return 0;
		int res=1,y=(x+mod)%mod;
		for(;n;n>>=1,y=(ll)y*y%mod)
			if(n&1)res=(ll)res*y%mod;
		return res;
	}
	template<int mod,typename U>
	int qpow(int x,U n){
		if(mod==1)return 0;
		int res=1,y=(x+mod)%mod;
		for(;n;n>>=1,y=(ll)y*y%mod)
			if(n&1)res=(ll)res*y%mod;
		return res;
	}
	template<typename T,typename U>
	T qpow(T x,U n,ll mod){
		if(mod==1)return 0;
		T res=1,y=(x+mod)%mod;
		for(;n;n>>=1,y=(__int128)y*y%mod)
			if(n&1)res=(__int128)res*y%mod;
		return res;
	}
	template<ll mod,typename T,typename U>
	T qpow(T x,U n){
		if(mod==1)return 0;
		T res=1,y=(x+mod)%mod;
		for(;n;n>>=1,y=(__int128)y*y%mod)
			if(n&1)res=(__int128)res*y%mod;
		return res;
	}
	template<typename T>
	T exgcd(T a,T b,T &x,T &y){
		if(!b)return x=1,y=0,a;
		T d=exgcd(b,a%b,y,x);y-=a/b*x;
		return d;
	}
	bool is_prime(int n){
		if(n<=1)return false;
		static constexpr int base[]={2,7,61};
		for(auto a:base)
			if(n==a)
				return true;
		if(n%2==0)return false;
		int d=n-1;
		while(d%2==0)d/=2;
		for(auto a:base){
			int t=d,y=qpow(a,t,n);
			while(t!=n-1&&y!=1&&y!=n-1)
				y=(ll)y*y%n,t<<=1;
			if(y!=n-1&&t%2==0)
				return false;
		}
		return true;
	}
	template<typename T>
	bool is_prime(T n){
		if(n<=1)return false;
		static constexpr ll base[]={2,325,9375,28178,450775,9780504,1795265022};
		if(n%2==0)return (n==2);
		T d=n-1;
		while(d%2==0)d/=2;
		for(auto a:base){
			if(a%n==0)continue;
			T t=d,y=qpow(a,t,n);
			while(t!=n-1&&y!=1&&y!=n-1)
				y=(__int128)y*y%n,t<<=1;
			if(y!=n-1&&t%2==0)
				return false;
		}
		return true;
	}
	
	std::vector<std::pair<int,int>>factorize(int n){
		std::vector<std::pair<int,int>> v;
		auto check=[&](int i){
			if(n%i==0){
				v.emplace_back(i,0);
				int cnt=0;
				for(;n%i==0;++cnt,n/=i);
			}
		};
		check(2);
		check(3);
		for(int i=5;i*i<=n;i+=6){
			check(i);
			check(i+2);
		}
		if(n>1){
			v.emplace_back(n,1);
		}
		return v;
	}
	
	template<typename T>
	std::vector<std::pair<T,int>> factorize(T n){
		auto private_factorize=[&](auto self,T n,std::vector<T> &lis)-> void {
			static constexpr int B=256;
			if(is_prime(n))
				return lis.emplace_back(n),void();
			for(T c=2;;c++){
				T x=0,y=2,by=0,z=1,d=1;
				for(int l=1;d==1;l<<=1){
					x=y;
					for(int i=0;i<l;i++)y=(static_cast<__int128>(y)*y+c)%n;
					for(int i=0;i<l;i+=B){
						by=y;
						for(int j=0;j<B&&j<l-i;j++){
							y=(static_cast<__int128>(y)*y+c)%n;
							z=(static_cast<__int128>(z)*(y-x))%n;
						}
						if((d=std::__gcd(z,n))!=1)break;
					}
				}
				if(d==n){
					for(y=by;;){
						y=(static_cast<__int128>(y)*y+c)%n;
						if((d=std::__gcd(y-x,n))!=1)break;
					}
				}
				if(d!=n){
					self(self,d,lis),self(self,n/d,lis);
					return;
				}
			}
		};
		if(n==1)return std::vector<std::pair<T,int>>{};
		std::vector<std::pair<T,int>>res;
		int s=__builtin_ctzll(n);
		if(s)res.emplace_back(2,s);
		n>>=s;
		std::vector<ll>lis;
		private_factorize(private_factorize,n,lis);
		sort(lis.begin(),lis.end());
		for (int i=0,j=0;i<(int)lis.size();i=j){
			for(;j<(int)lis.size()&&lis[i]==lis[j];j++){}
			res.emplace_back(lis[i],j-i);
		}
		return res;
	}
	
	template<uint mod>
	struct factorization_list{
	public:
		factorization_list():fac(1,1){}
		void expand(int p){
			int pre=fac.size();
			if(pre>p)return;
			fac.resize(p+1);
			for(int i=pre;i<=p;i++){
				fac[i]=(ll)fac[i-1]*i%mod;
			}
		}
		int operator [](int x){
			assert(x>=0);
			expand(x);
			return fac[x];
		}
	private:
		std::vector<int>fac;
	};
	template<uint mod>
	struct inverse_list{
	public:
		inverse_list():inv(2,1){}
		void expand(int p){
			int pre=inv.size();
			if(pre>p)return;
			inv.resize(p+1);
			for(int i=pre;i<=p;i++)
				inv[i]=(ll)(mod-mod/i)*inv[mod%i]%mod;
		}
		int operator [](int x){
			assert(x>=0);
			expand(x);
			return inv[x];
		}
	private:
		std::vector<int>inv;
	};
	template<uint mod>
	struct inverse_factorization_list{
	public:
		inverse_factorization_list():inv(),ifac(2,1){}
		void expand(int p){
			int pre=ifac.size();
			if(pre>p)return;
			inv.expand(p);
			ifac.resize(p+1);
			for(int i=pre;i<=p;i++){
				ifac[i]=(ll)ifac[i-1]*inv[i]%mod;
			}
		}
		int operator [](int x){
			assert(x>=0);
			expand(x);
			return ifac[x];
		}
	private:
		inverse_list<mod>inv;
		std::vector<int>ifac;
	};
	template<uint mod>
	struct binom_list{
	public:
		void expand(int x){
			fac.expand(x);
			ifac.expand(x);
		}
		int operator()(int x,int y){
			if(x<0||y<0||x<y)return 0;
			expand(x);
			return (ll)fac[x]*ifac[y]%mod*ifac[x-y]%mod;
		}
	private:
		factorization_list<mod>fac;
		inverse_factorization_list<mod>ifac;
	};
}

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
	cin.tie(nullptr)->sync_with_stdio(false);
	ll n;
	while(cin>>n){
		cout<<(exodus::is_prime<ll>(n)?'Y':'N')<<'\n';
	}
	return 0;
}