#include <bits/stdc++.h>

typedef unsigned long long u64;

template<typename T, typename UT> class montctx_t {
private:
    typedef T val_t;
    typedef UT mval_t;
    static const int tlen = sizeof(val_t) * 8;
public:
    val_t mdn, mdn2, p2, r;
    montctx_t(val_t x): mdn(x), mdn2(x << 1), p2(-mval_t(mdn) % mdn), r(1) {
        for (int i = 1; i < tlen; i <<= 1)
            r *= 2 + r * mdn;
    }
    inline val_t redc(mval_t x)const {
        return (x + (val_t(x) * r) * mval_t(mdn)) >> tlen;
    }
    inline val_t redu(val_t x)const {
        return x >= mdn2 ? x - mdn2 : x;
    }
    inline val_t reds(val_t x)const {
        return x >= mdn ? x - mdn : x;
    }
};
//# 30 31
typedef montctx_t<uint32_t, uint64_t> montctx32_t;
//# 62 63
typedef montctx_t<uint64_t, unsigned __int128> montctx64_t;
//# 30 62
template<typename T, typename UT> class mont_t {
private:
    typedef T val_t;
    typedef UT mval_t;
    static montctx_t<T, UT> ctx;
    val_t v;
public:
    static montctx_t<T, UT> getctx() {
        return ctx;
    }
    static void setctx(const montctx_t<T, UT> &x) {
        ctx = x;
    }

    explicit operator val_t()const {
        return ctx.reds(ctx.redc(v));
    }
    mont_t(val_t x) {
        v = ctx.redc(x * (mval_t)ctx.p2);
    }
    mont_t() {}
    mont_t(const mont_t &a): v(a.v) {}
    mont_t &operator+=(const mont_t &a) {
        v = ctx.redu(v + a.v);
        return*this;
    }
    mont_t &operator-=(const mont_t &a) {
        v = ctx.redu(v - a.v + ctx.mdn2);
        return*this;
    }
    mont_t &operator*=(const mont_t &a) {
        v = ctx.redc(v * (mval_t)a.v);
        return*this;
    }
    mont_t &operator=(const mont_t &a) {
        v = a.v;
        return*this;
    }
    mont_t operator+(const mont_t &a)const {
        return mont_t(*this) += a;
    }
    mont_t operator-(const mont_t &a)const {
        return mont_t(*this) -= a;
    }
    mont_t operator*(const mont_t &a)const {
        return mont_t(*this) *= a;
    }
    mont_t operator-()const {
        mont_t r;
        r.v = (v ? ctx.mdn2 - v : 0);
        return r;
    }
    bool operator==(const mont_t &a)const {
        return ctx.reds(v) == ctx.reds(a.v);
    }
    bool operator!=(const mont_t &a)const {
        return !(*this == a);
    }
    friend std::istream &operator>>(std::istream &s, mont_t &v) {
        val_t tmp;
        s >> tmp;
        v = mont_t(tmp);
        return s;
    }
    friend std::ostream &operator<<(std::ostream &s, const mont_t &v) {
        return s << val_t(v);
    }
};
//# 30
typedef mont_t<uint32_t, uint64_t> mont30_t;
template<> montctx32_t mont30_t::ctx = montctx32_t(998244353);
//# 62
typedef mont_t<uint64_t, unsigned __int128> mont62_t;
template<> montctx64_t mont62_t::ctx = montctx64_t(998244353);
//# 31 63
template<typename T, typename UT> class mont_e_t {
private:
    typedef T val_t;
    typedef UT mval_t;
    static montctx_t<T, UT> ctx;
    val_t v;
public:
    static montctx_t<T, UT> getctx() {
        return ctx;
    }
    static void setctx(const montctx_t<T, UT> &x) {
        ctx = x;
    }

    explicit operator val_t()const {
        return ctx.reds(ctx.redc(v));
    }
    mont_e_t(val_t x) {
        v = ctx.reds(ctx.redc(x * (mval_t)ctx.p2));
    }
    mont_e_t() {}
    mont_e_t(const mont_e_t &a): v(a.v) {}
    mont_e_t &operator+=(const mont_e_t &a) {
        v = ctx.reds(v + a.v);
        return*this;
    }
    mont_e_t &operator-=(const mont_e_t &a) {
        v = ctx.reds(v - a.v + ctx.mdn);
        return*this;
    }
    mont_e_t &operator*=(const mont_e_t &a) {
        v = ctx.reds(ctx.redc(v * (mval_t)a.v));
        return*this;
    }
    mont_e_t &operator=(const mont_e_t &a) {
        v = a.v;
        return*this;
    }
    mont_e_t operator+(const mont_e_t &a)const {
        return mont_e_t(*this) += a;
    }
    mont_e_t operator-(const mont_e_t &a)const {
        return mont_e_t(*this) -= a;
    }
    mont_e_t operator*(const mont_e_t &a)const {
        return mont_e_t(*this) *= a;
    }
    mont_e_t operator-()const {
        mont_e_t r;
        r.v = (v ? ctx.mdn - v : 0);
        return r;
    }
    bool operator==(const mont_e_t &a)const {
        return v == a.v;
    }
    bool operator!=(const mont_e_t &a)const {
        return !(*this == a);
    }
    friend std::istream &operator>>(std::istream &s, mont_e_t &v) {
        val_t tmp;
        s >> tmp;
        v = mont_e_t(tmp);
        return s;
    }
    friend std::ostream &operator<<(std::ostream &s, const mont_e_t &v) {
        return s << val_t(v);
    }
};
//# 31
typedef mont_e_t<uint32_t, uint64_t> mont31_t;
template<> montctx32_t mont31_t::ctx = montctx32_t(998244353);
//# 63
typedef mont_e_t<uint64_t, unsigned __int128> mont63_t;
template<> montctx64_t mont63_t::ctx = montctx64_t(998244353);
//#

const int N = 5;

u64 n;

struct mat {
    mont63_t a[N][N];
};

mat *I, *P, *Q;

inline void MatMul(mat *A, mat *B, mat *C) {
    for (int i = 0; i < N; ++i)
        for (int j = i; j < N; ++j) {
            C->a[i][j] = 0;

            for (int k = 0; k < N; ++k)
                C->a[i][j] += A->a[i][k] * B->a[k][j];

            if (i != j)
                C->a[j][i] = C->a[i][j];
        }
}

inline mat QuickPow(mat *R, u64 n) {
    mat mre = *R, mbb = *I, mt = *I;
    mat *re = &mre, *bb = &mbb, *t = &mt;

    while (n > 0) {
        if (n & 1) {
            MatMul(bb, re, t);
            std::swap(t, bb);
        }

        n >>= 1;
        MatMul(re, re, t);
        std::swap(t, re);
    }

    return *bb;
}

bool isP(mat *x, mat *y) {
    for (int i = 0; i < N; ++i)
        if (x->a[i][i] != y->a[i][i] + 1)
            return 0;

    for (int i = 0; i < N; ++i)
        for (int j = i + 1; j < N; ++j)
            if (x->a[i][j] != y->a[i][j])
                return 0;

    return 1;
}

void init_mat() {
    I = new mat({1, 0, 0, 0, 0,
                 0, 1, 0, 0, 0,
                 0, 0, 1, 0, 0,
                 0, 0, 0, 1, 0,
                 0, 0, 0, 0, 1});
    P = new mat({   1,  2,  5,  11, 37,
                    2,  1,  17, 31, 13,
                    5,  17, 1,  23, 7,
                    11, 31, 23, 1,  3,
                    37, 13, 7,  3,  1   });
    Q = new mat({   0,  2,  5,  11, 37,
                    2,  0,  17, 31, 13,
                    5,  17, 0,  23, 7,
                    11, 31, 23, 0,  3,
                    37, 13, 7,  3,  0   });
}

int main() {
    while (scanf("%llu", &n) != EOF) {
        if (n == 1) {
            puts("N");
            continue;
        }

        if (n <= 100) {
            bool flg = 1;

            for (int i = 2; i * i <= n; ++i)
                if (n % i == 0) {
                    flg = 0;
                    break;
                }

            puts(flg ? "Y" : "N");
            continue;
        }

        if (n % 2 == 0) {
            puts("N");
            continue;
        }

        mont63_t::setctx(montctx64_t(n));
        init_mat();
        mat PP = QuickPow(P, n), QQ = QuickPow(Q, n);
        //for (int i = 0; i < N; ++i, printf("\n"))
        //  for (int j = 0; j < N; ++j) printf("%llu ", PP.a[i][j]);
        //for (int i = 0; i < N; ++i, printf("\n"))
        //  for (int j = 0; j < N; ++j) printf("%llu ", QQ.a[i][j]);
        puts(isP(&PP, &QQ) ? "Y" : "N");
    }

    return 0;
}