#include <bits/stdc++.h>

using namespace std;

constexpr int R = 10, C = 9, T = 6, D = 20;

int dist[T][R][C][R][C];

uint64_t splitmix(uint64_t x) {
  x += 457942364158234254782354781547;
  (x ^= x >> 30) *= 37843589425368942534595923;
  (x ^= x >> 27) *= 86345123452145542195491921;
  return x;
}

map<uint64_t, int> mem;

array<int, 3> build(vector<array<int, 3>> v, int alpha, int beta) {
  uint64_t h = 0;
  for (auto [a, b, c]: v) h = splitmix(h + a * 100 + b * 10 + c);
  array<int, 3> res{alpha + 1};
  if (mem.count(h)) {
    auto x = mem[h];
    int lo = x / 1000000, hi = x / 10000 % 100, r = x / 100 % 100, c = x % 100;
    if (lo > alpha) return {lo};
    if (lo == hi || hi <= beta) return {hi, r, c};
    if (hi <= alpha) res = {hi, r, c};
  }
  vector<array<int, 3>> opt;
  array<int, D> cnt, mask;
  {
    int m = 0;
    for (auto [t, R, C]: v) m |= 1 << t;
    if (__builtin_popcount(m) <= 1) return {};
  }
  for (int r = R; r--; )
  for (int c = C; c--; ) {
    cnt = mask = {};
    for (auto [t, R, C]: v) ++cnt[dist[t][R][C][r][c] + 1], mask[dist[t][R][C][r][c] + 1] |= 1 << t;
    int mx = 0;
    for (auto mask: mask) mx = max(mx, __builtin_popcount(mask));
    if (mx == 1) { mem[h] = 10000 + r * 100 + c; return {1, r, c}; }
    if (alpha > 1 && *max_element(cnt.begin(), cnt.end()) < v.size()) opt.push_back({-1, r, c});
  }
  static mt19937_64 rng(231313);
  shuffle(opt.begin(), opt.end(), rng);
  vector<vector<array<int, 3>>> part(D);
  vector<array<int, 2>> ord;
  int early = 0;
  for (auto [_, r, c]: opt) {
    int d = r / 2 % 2 * 4 + c / 2 % 2 * 2 + (r / 2 + c / 2) % 2;
    for (auto& part: part) part.clear();
    for (auto [t, R, C]: v) part[dist[t][R][C][r][c] + 1].push_back({t, R, C});
    ord.clear();
    for (int i = D; i--; ) if (part[i].size() > 1) ord.push_back({part[i].size(), i});
    sort(ord.rbegin(), ord.rend());
    int mx = 1;
    for (auto [_, i]: ord) {
      int cur = build(move(part[i]), res[0] - 2, max(mx, beta) - 1)[0] + 1;
      mx = max(mx, cur);
      if (mx >= res[0]) break;
    }
    if (mx < res[0]) res = {mx, r, c};
    if (early = mx <= beta) break;
  }
  int lo = 0, hi = 99, r = 0, c = 0;
  if (res[0] <= alpha) hi = res[0], r = res[1], c = res[2];
  if (!early) lo = res[0];
  if (mem.count(h)) {
    auto x = mem[h];
    int lo_ = x / 1000000, hi_ = x / 10000 % 100, r_ = x / 100 % 100, c_ = x % 100;
    if (hi_ < hi) hi = hi_, r = r_, c = c_;
    if (lo_ > lo) lo = lo_;
  }
  mem[h] = lo * 1000000 + hi * 10000 + r * 100 + c;
  return res;
}

int main() {
  fill(****dist, ****end(dist), -1);
  for (int t = T; t--; )
  for (int rr = R; rr--; )
  for (int cc = C; cc--; ) {
    vector<array<int, 2>> q, nq{{rr, cc}};
    int d = 0;
    dist[t][rr][cc][rr][cc] = 0;
    while (++d, swap(q = {}, nq), q.size())
    for (auto [r, c]: q)
    for (int R = ::R; R--; )
    for (int C = ::C; C--; ) if (!~dist[t][rr][cc][R][C] && (
        t == 0? abs(r - R) + abs(c - C) == 1:
        t == 1? abs((r - R) * (c - C)) == 1:
        t == 2? (r - R) * (c - C) == 0:
        t == 3? abs((r - R) * (c - C)) == 2:
        t == 4? (r - R) * (r - R) + (c - C) * (c - C) == 8:
        R == r + 1 && c == C || R == r && abs(c - C) == (r > 4))) {
      dist[t][rr][cc][R][C] = d;
      nq.push_back({R, C});
    }
  }
  int n; cin >> n;
  vector<array<int, 3>> v;
  for (int i = 0; i < n; ++i) {
    int r, c; cin >> r >> c;
    for (int t = T; t--; ) v.push_back({t, r, c});
  }
  int m = build(v, 99, 0)[0];
  cout << m << '\n';
  for (int i = 0; i < m; ++i) {
    auto [m, r, c] = build(v, 99, 0);
    cout << "? " << r << ' ' << c << '\n';
    int d; cin >> d;
    v.erase(remove_if(v.begin(), v.end(), [&](auto& x) { auto [t, R, C] = x; return dist[t][R][C][r][c] != d; }), v.end());
    assert(v.size());
  }
  {
    int m = 0;
    for (auto& [t, r, c]: v) m |= 1 << t;
    assert(!(m & m - 1));
  }
  cout << "! " << "JSCMXB"[v[0][0]] << '\n';
}