#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read_to_vector(size_t N, std::vector<T> &v) {
  for (size_t i = 0; i < N; i++) {
    T tmp;
    std::cin >> tmp;
    v.push_back(tmp);
  }
}
template <typename T>
void print_vector(const std::vector<T> &v) {
  for (auto it = v.begin(); it < v.end(); it++) {
    if (it != v.begin()) std::cout << " ";
    std::cout << (*it);
  }
}
map<vector<int>, int> qmemo;
long long query(vector<int> s) {
  if (s.size() <= 1) {
    return 0;
  }
  sort(s.begin(), s.end());
  if (qmemo.count(s)) {
    return qmemo[s];
  }
  cout << "? " << s.size() << endl;
  for (int i : s) {
    cout << (i + 1) << " ";
  }
  cout << endl;
  long long res = 0;
  cin >> res;
  return qmemo[s] = res;
}
long long query(vector<vector<int>> ss) {
  vector<int> xx;
  for (auto &s : ss) {
    xx.insert(xx.end(), s.begin(), s.end());
  }
  sort(xx.begin(), xx.end());
  return query(xx);
}
std::pair<int, int> findedgeone(vector<int> A) {
  int num = query(A);
  int i;
  while (true) {
    i = A.back();
    A.pop_back();
    if (query(A) < num) {
      break;
    }
  }
  for (auto u : A) {
    if (query({i, u}) > 0) {
      return make_pair(i, u);
    }
  }
}
std::pair<int, int> findedge(vector<int> &A, vector<int> &B) {
  if (A.size() < B.size()) {
    auto res = findedge(B, A);
    return make_pair(res.second, res.first);
  }
  if (A.size() == 1) {
    return make_pair(A[0], B[0]);
  }
  vector<int> A0;
  vector<int> A1;
  for (int i = 0; i < A.size(); i++) {
    if (i & 1) {
      A0.push_back(A[i]);
    } else {
      A1.push_back(A[i]);
    }
  }
  long long nB = query(B);
  long long nA0 = query(A0);
  long long nA0B = query(vector<vector<int>>({A0, B}));
  if (nA0B > nA0 + nB) {
    return findedge(A0, B);
  } else {
    return findedge(A1, B);
  }
}
void solve() {
  int n;
  cin >> n;
  vector<int> A;
  A.push_back(0);
  vector<int> B;
  for (int i = 1; i < n; i++) {
    B.push_back(i);
  }
  B.push_back(0);
  long long NTOT = query(B);
  B.pop_back();
  vector<int> assign(n);
  vector<vector<int>> edges(n);
  for (int i = 1; i < n; i++) {
    long long nA = query(A);
    long long nB = query(B);
    if (NTOT == nA + nB) {
      A.push_back(B.back());
      B.pop_back();
      continue;
    }
    std::pair<int, int> xx = findedge(A, B);
    int a = xx.first;
    int b = xx.second;
    edges[a].push_back(b);
    edges[b].push_back(a);
    assign[b] = !assign[a];
    A.push_back(b);
    B.erase(find(B.begin(), B.end(), b));
  }
  vector<int> A0;
  vector<int> A1;
  for (int i = 0; i < n; i++) {
    if (assign[i]) {
      A1.push_back(i);
    } else {
      A0.push_back(i);
    }
  }
  if (query(A0) > 0) {
    std::pair<int, int> xx = findedgeone(A0);
    edges[xx.first].push_back(xx.second);
    edges[xx.second].push_back(xx.first);
  } else if (query(A1) > 0) {
    std::pair<int, int> xx = findedgeone(A1);
    edges[xx.first].push_back(xx.second);
    edges[xx.second].push_back(xx.first);
  } else {
    cout << "Y\n";
    cout << A0.size();
    for (auto a : A0) {
      cout << " " << (a + 1);
    }
    cout << endl;
    return;
  }
  for (int i = 0; i < n; i++) {
    vector<bool> used(n, false);
    vector<int> dist(n, 0);
    vector<int> prev(n, 0);
    queue<int> q;
    q.push(i);
    used[i] = true;
    while (!q.empty()) {
      int u = q.front();
      q.pop();
      for (auto v : edges[u]) {
        if (used[v] && (dist[v] % 2 == dist[u] % 2)) {
          vector<int> res;
          int vv = v;
          int uu = u;
          while (true) {
            if (vv == uu) {
              res.push_back(uu);
              break;
            }
            res.push_back(vv);
            res.insert(res.begin(), uu);
            int d = dist[vv] - dist[uu];
            if (d > 0) {
              vv = prev[i];
            } else if (d < 0) {
              uu = prev[i];
            } else {
              vv = prev[vv];
              uu = prev[uu];
            }
          }
          cout << "N\n";
          cout << res.size();
          for (auto x : res) {
            cout << " " << (x + 1);
          }
          cout << endl;
          return;
        }
        if (!used[v]) {
          dist[v] = dist[u] + 1;
          prev[v] = u;
          q.push(v);
          used[v] = true;
        }
      }
    }
  }
}
void pre_compute() {}
int main() {
  std::cout << std::setprecision(15);
  pre_compute();
  solve();
  return 0;
}
