#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


bool solve(Int N) {
  vector<int> es;
  Int n = N;
  for (Int p = 2; p*p <= n; ++p) if (n % p == 0) {
    int e = 0;
    do { ++e; n /= p; } while (n % p == 0);
    es.push_back(e);
  }
  if (n > 1) es.push_back(1);
  if (es.size() == 1 && es[0] % 2 != 0) return true;
  if (es.size() == 2 && es[0] == 1 && es[1] == 1) return true;
  return false;
}


namespace exper {
int N;
int dsLen;
vector<int> ds;

map<pair<int, int>, int> cache[2];
int calc(int turn, int alice, int rem) {
  const pair<int, int> key(alice, rem);
  auto it = cache[turn].find(key);
  if (it != cache[turn].end()) return it->second;
  int ret = 0;
  
  if (rem) {
    for (int i = 0; i < dsLen; ++i) if (rem & 1 << i) {
      if (!calc(turn ^ 1, turn ? (alice | 1 << i) : alice, rem ^ 1 << i)) {
        ret = 1;
      }
    }
  } else {
    int g = 0;
    for (int i = 0; i < dsLen; ++i) if (alice & 1 << i) {
      g = __gcd(g, ds[i]);
    }
    ret = turn ? (g != 1) : (g == 1);
  }
  
  return cache[turn][key] = ret;
}
void run() {
  for (N = 1; N < 120; ++N) {
    ds.clear();
    for (int d = 1; d <= N; ++d) if (N % d == 0) ds.push_back(d);
    dsLen = ds.size();
    assert(dsLen <= 16);
    for (int turn = 0; turn < 2; ++turn) cache[turn].clear();
    const bool brt = calc(1, 0, (1 << dsLen) - 1);
    const bool slv = solve(N);
    if (brt || brt != slv) {
      cerr << N << " " << ds << ": " << brt << " " << slv << endl;
    }
    assert(brt == slv);
  }
}
}  // exper


int main() {
  // exper::run();
  
  Int N;
  for (; ~scanf("%lld", &N); ) {
    const bool ans = solve(N);
    puts(ans ? "Y" : "N");
  }
  return 0;
}