#include "bits/stdc++.h"


#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i < (n); ++i)
#define rep1n(i, n) for (int i = 1; i <= (n); ++i)
#define repr(i, n) for (int i = (n) - 1; i >= 0; --i)
#define pb push_back
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define each(x, a) for (auto &x : a)
#define ar array
#define vec vector
#define range(i, n) rep(i, n)

using namespace std;

using ll = long long;
using ull = unsigned long long;
using ld = long double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;

using vi = vector<int>;
using vl = vector<ll>;
using vpi = vector<pair<int, int>>;
using vvi = vector<vi>;

int Bit(int mask, int b) { return (mask >> b) & 1; }

template<class T>
bool ckmin(T &a, const T &b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
bool ckmax(T &a, const T &b) {
    if (b > a) {
        a = b;
        return true;
    }
    return false;
}

// [l, r)
template<typename T, typename F>
T FindFirstTrue(T l, T r, const F &predicat) {
    --l;
    while (r - l > 1) {
        T mid = l + (r - l) / 2;
        if (predicat(mid)) {
            r = mid;
        } else {
            l = mid;
        }
    }
    return r;
}


template<typename T, typename F>
T FindLastFalse(T l, T r, const F &predicat) {
    return FindFirstTrue(l, r, predicat) - 1;
}

const int INFi = 2e9;
const ll INF = 2e18;
const int LG = 20;

const int F = 6;
const int SZ = 90;

const int BSZ = F * SZ;
using Bitset = bitset<BSZ>;

Bitset who[SZ][SZ];
bool ok[SZ][SZ];

const int N = 10;
const int M = 9;
void Add(int f, vpi &steps, bool kek=false) {
    rep(i, SZ) {
        vector<vi> d(N, vi(M, -1));
        queue<pair<int, int>> q;
        d[i / M][i % M] = 0;
        q.push({i / M, i % M});
        if (!kek) {
            while (!q.empty()) {
                auto [x, y] = q.front();
                q.pop();
                for (auto &[dx, dy]: steps) {
                    int x2 = x + dx;
                    int y2 = y + dy;
                    if (x2 < 0 || x2 >= N || y2 < 0 || y2 >= M) continue;
                    if (d[x2][y2] == -1) {
                        d[x2][y2] = d[x][y] + 1;
                        q.push({x2, y2});
                    }
                }
            }
        } else {
            while (!q.empty()) {
                auto [x, y] = q.front();
                q.pop();
                for (auto &[dx, dy]: steps) {
                    int x2 = x + dx;
                    int y2 = y + dy;
                    if (x2 < 0 || x2 >= N || y2 < 0 || y2 >= M) continue;
                    if (d[x2][y2] == -1) {
                        d[x2][y2] = d[x][y] + 1;
                        q.push({x2, y2});
                    }
                    if (x <= 4) break;
                }
            }
        }
        rep(x, N) {
            rep(y, M) {
                int val = d[x][y] + 1;
                ok[x * M + y][val] = true;
                who[x * M + y][val][f * SZ + i] = 1;
            }
        }
    }
}


//struct CMP {
//
//    bool operator()(const Bitset &a, const)
//};
struct CMP {
    bool operator()(const Bitset &a, const Bitset &b) const {
        if (a == b) return false;
        int bit = (a ^ b)._Find_first();
        return b[bit];
    }
};

map<Bitset, int, CMP> mp;

int Go(const Bitset &b, int mx_ans = 90) {
    if (mp.contains(b)) return mp[b];
    {
        int f = b._Find_first() / SZ;
        if (f + 1 == F || b._Find_next((f + 1) * SZ - 1) == BSZ) {
            return 0;
        }
    }
    if (mx_ans <= 0) return 1;
    int res = INFi;
    rep(i, SZ) {
        if (res == 1) break;
        int val = -1;
        rep(t, SZ) {
            if (!ok[i][t]) continue;
            auto q = who[i][t] & b;
            if (q == 0) continue;
            if (q == b) {
                val = INFi;
                break;
            }
            ckmax(val, Go(q, min(res - 1, mx_ans - 1)) + 1);
            if (val >= res || val > mx_ans) break;
        }
        if (val == INFi) continue;
        assert(val != -1);
        assert(val < INFi);
        ckmin(res, val);
    }
    assert(res != INFi);
    if (res > mx_ans) return mx_ans + 1;
    return mp[b] = res;
}

void solve() {
    int n; cin >> n;
    Bitset start = 0;
    rep(i, n) {
        int r = i / M, c = i % M;
        cin >> r >> c;
        int pos = r * 9 + c;
        rep(j, F) start[pos + j * SZ] = 1;
    }

    {
        vpi cur;
        cur.emplace_back(1, 0);
        cur.emplace_back(-1, 0);
        cur.emplace_back(0, 1);
        cur.emplace_back(0, -1);
        Add(0, cur);
    }

    {
        vpi cur;
        cur.emplace_back(1, 1);
        cur.emplace_back(-1, 1);
        cur.emplace_back(-1, -1);
        cur.emplace_back(1, -1);
        Add(1, cur);
    }
    {

        vpi cur;
        for(int x = -9; x <= 9; ++x) {
            if (x) cur.emplace_back(x, 0);
        }
        for(int x = -8; x <= 8; ++x) {
            if (x) cur.emplace_back(0, x);
        }
        Add(2, cur);
    }

    {
        vpi cur;
        for(int x = -2; x <= 2; ++x) {
            for(int y = -2; y <= 2; ++y) {
                if (abs(x) + abs(y) == 3) {
                    cur.emplace_back(x, y);
                }
            }
        }
        Add(3, cur);
    }
    {
        vpi cur;
        for(int x = -2; x <= 2; ++x) {
            for(int y = -2; y <= 2; ++y) {
                if (abs(x) + abs(y) == 4) {
                    cur.emplace_back(x, y);
                }
            }
        }
        Add(4, cur);
    }
    {
        // Pawn
        vpi cur;
        cur.emplace_back(1, 0);
        cur.emplace_back(0, 1);
        cur.emplace_back(0, -1);
        Add(5, cur, true);
    }

    int ans = Go(start);
    cout << ans << endl;

    auto b = start;
    while(ans > 0) {
        int k = -1;
        rep(i, SZ) {
            int val = -1;
            rep(t, SZ) {
                if (!ok[i][t]) continue;
                auto q = who[i][t] & b;
                if (q == 0) continue;
                if (q == b) {
                    val = INFi;
                    break;
                }
                ckmax(val, Go(q, ans - 1) + 1);
                if (val > ans) break;
            }
            if (val > ans) continue;
            assert(val != -1);
            assert(val == ans);
            k = i;
            break;
        }
        cout << "? " << k / M << ' ' << k % M << endl;
        int d; cin >> d;
        d++;

        b = who[k][d] & b;
        ans--;
    }

    string S = "JSCMXB";
    int f = b._Find_first() / SZ;
    if (f + 1 == F || b._Find_next((f + 1) * SZ - 1) == BSZ) {
        cout << "! " << S[f] << endl;
        return;
    }
    assert(0);
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout << setprecision(12) << fixed;
    int t = 1;
//    cin >> t;
    rep(i, t) {
        solve();
    }
    return 0;
}