#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using u128 = unsigned __int128;

using State = std::array<int, 3>;
constexpr std::string symbol = "JSCMXB";

std::map<std::vector<State>, std::array<int, 2>> op;

int dis[6][10][9][10][9];

std::vector<std::array<int, 2>> moves[6];

bool check(std::vector<State> cand, int m) {
    {
        bool same = true;
        for (auto s : cand) {
            if (s[2] != cand[0][2]) {
                same = false;
                break;
            }
        }
        if (same) {
            op[cand] = {-1, cand[0][2]};
            return true;
        }
    }
    if (m == 0) {
        return false;
    }
    
    for (int r = 0; r < 10; r++) {
        for (int c = 0; c < 9; c++) {
            std::map<int, std::vector<State>> f;
            for (auto [x, y, t] : cand) {
                f[dis[t][x][y][r][c]].push_back({x, y, t});
            }
            if (f.size() == 1) {
                continue;
            }
            
            bool ok = true;
            for (auto [_, c] : f) {
                if (!check(c, m - 1)) {
                    ok = false;
                    break;
                }
            }
            if (ok) {
                op[cand] = {r, c};
                return true;
            }
        }
    }
    
    return false;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    std::memset(dis, -1, sizeof(dis));
    
    moves[0].push_back({1, 0});
    moves[0].push_back({-1, 0});
    moves[0].push_back({0, 1});
    moves[0].push_back({0, -1});
    
    moves[1].push_back({1, 1});
    moves[1].push_back({1, -1});
    moves[1].push_back({-1, 1});
    moves[1].push_back({-1, -1});
    
    for (int x = -9; x <= 9; x++) {
        if (x) {
            moves[2].push_back({x, 0});
        }
    }
    for (int y = -8; y <= 8; y++) {
        if (y) {
            moves[2].push_back({0, y});
        }
    }
    
    moves[3].push_back({2, 1});
    moves[3].push_back({2, -1});
    moves[3].push_back({-2, 1});
    moves[3].push_back({-2, -1});
    moves[3].push_back({1, 2});
    moves[3].push_back({1, -2});
    moves[3].push_back({-1, 2});
    moves[3].push_back({-1, -2});
    
    moves[4].push_back({2, 2});
    moves[4].push_back({2, -2});
    moves[4].push_back({-2, 2});
    moves[4].push_back({-2, -2});
    
    moves[5].push_back({1, 0});
    moves[5].push_back({0, 1});
    moves[5].push_back({0, -1});
    
    for (int t = 0; t < 6; t++) {
        for (int r = 0; r < 10; r++) {
            for (int c = 0; c < 9; c++) {
                std::queue<std::array<int, 2>> q;
                q.push({r, c});
                dis[t][r][c][r][c] = 0;
                
                while (!q.empty()) {
                    auto [x, y] = q.front();
                    q.pop();
                    
                    for (auto [dx, dy] : moves[t]) {
                        if (t == 5 && x <= 4 && dy) {
                            continue;
                        }
                        int nx = x + dx;
                        int ny = y + dy;
                        if (0 <= nx && nx < 10 && 0 <= ny && ny < 9 && dis[t][r][c][nx][ny] == -1) {
                            dis[t][r][c][nx][ny] = dis[t][r][c][x][y] + 1;
                            q.push({nx, ny});
                        }
                    }
                }
            }
        }
    }
    
    int n;
    std::cin >> n;
    
    std::vector<State> cand;
    
    for (int i = 0; i < n; i++) {
        int r, c;
        std::cin >> r >> c;
        
        for (int t = 0; t < 6; t++) {
            cand.push_back({r, c, t});
        }
    }
    std::sort(cand.begin(), cand.end());
    
    int m = 1;
    while (!check(cand, m)) {
        op.clear();
        m++;
    }
    
    std::cout << m << std::endl;
    
    while (true) {
        auto [r, c] = op[cand];
        
        if (r < 0) {
            std::cout << "! " << symbol[c] << std::endl;
            break;
        }
        
        std::cout << "? " << r << " " << c << std::endl;
        int res;
        std::cin >> res;
        
        std::vector<State> nc;
        for (auto [x, y, t] : cand) {
            if (dis[t][x][y][r][c] == res) {
                nc.push_back({x, y, t});
            }
        }
        cand = nc;
    }
    
    return 0;
}