#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using ll   = long long;
using ull  = unsigned long long;
using ld   = long double;
using pii  = pair<int,int>;
using pll  = pair<ll,ll>;
using vi   = vector<int>;
using vb   = vector<bool>;
using vc   = vector<char>;
using vvc  = vector<vc>;
using vvi  = vector<vi>;
using vvb  = vector<vb>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using vll  = vector<ll>;
using vull = vector<ull>;
using vvll = vector<vll>;
using namespace __gnu_pbds;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define f first
#define s second
#define pb emplace_back
#define rep(i, begin, end) for(auto i = (begin); i <= (end); ++i)
#define repr(i, begin, end) for(auto i = (begin); i >= (end); --i)
#define bend(X) X.begin(), X.end()
#ifdef LOCAL
#define deb(...) cout << #__VA_ARGS__ << " = " << __VA_ARGS__ << endl
#define say(...) cout << __VA_ARGS__ << endl
#else
#define deb(x)
#define say(x)
#define endl '\n'
#endif
constexpr int INF = 1e9+1e7;
constexpr ll INFl = INF;
constexpr ll INFll = 1e18+1e16;
void print() { cout << '\n'; }
template <typename T, typename... Args> void print(T x, Args... args) { cout << x << ' '; print(args...); }
template <typename T1, typename T2> ostream& operator<<(ostream& os, pair<T1,T2> x) { os << x.f << ' ' << x.s; return os; }
template <typename T1, typename T2> istream& operator>>(istream& is, pair<T1,T2>& x) { is >> x.f >> x.s; return is; }
template <typename Ch, typename Tr, typename T> ostream& operator<<(basic_ostream<Ch,Tr>& os, T x) { for(auto i : x) os << i << ' '; return os; }
template <typename T> istream& operator>>(istream& is, vector<T>& x) { for(T& i : x) is >> i; return is; }
template <typename T1, typename T2> pair<T1,T2> operator+(const pair<T1,T2>& A, const pair<T1,T2>& B) { return {A.f+B.f, A.s+B.s}; }
template <typename T1, typename T2> pair<T1,T2> operator-(const pair<T1,T2>& A, const pair<T1,T2>& B) { return {A.f-B.f, A.s-B.s}; }
template <typename T1, typename T2> pair<T1,T2>& operator+=(pair<T1,T2>& A, const pair<T1,T2>& B) { A.f += B.f; A.s += B.s; return A; }
template <typename T1, typename T2> pair<T1,T2>& operator-=(pair<T1,T2>& A, const pair<T1,T2>& B) { A.f -= B.f; A.s -= B.s; return A; }
template <typename T1, typename T2> pair<T1,T2> operator-(const pair<T1,T2>& A) { return {-A.f, -A.s}; }
template <typename T, typename T1, typename T2> pair<T1,T2> operator*(const T& A, const pair<T1,T2>& B) { return {A*B.f, A*B.s}; }
template <typename T1, typename T2> bool maxe(T1& A, const T2& B) { if(B>A) { A=B; return 1; } return 0; }
template <typename T1, typename T2> bool mine(T1& A, const T2& B) { if(B<A) { A=B; return 1; } return 0; }
class Nic{} nic;
template <typename T> Nic operator<<(Nic, T) { return nic; }
Nic operator<<(ostream&, Nic) { return nic; }

//////////////////////////////////////////////////

vpii rookDir{{1,0},{-1,0},{0,1},{0,-1}};
vpii bishDir{{1,1},{1,-1},{-1,1},{-1,-1}};
vpii knigMov{{1,2},{2,1},{2,-1},{1,-2},{-1,-2},{-2,-1},{-2,1},{-1,2}};
vpii kingMov{{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}};

struct vertex {
    vector<vertex*> e;
    bool active = 0, vis = 0;
    pii pos;
    int deg() { return e.size(); }
    void emplace(vertex* u) { e.pb(u); }
};

constexpr int maxN = 100;
int n;
vertex G[maxN+5][maxN+5];
vector<pair<pii,pii>> R;

inline vertex* g(pii x) {
    return &G[x.f][x.s];
}

inline bool inside(pii x) {
    return x.f > 0 && x.f <= n && x.s > 0 && x.s <= n;
}
inline bool active(pii x) {
    return inside(x) && g(x)->active;
}

void addDir(pii x, const vpii& dirs) {
    for (auto dir : dirs)
        for (int s = 1; inside(x+s*dir); s++) {
            pii y = x+s*dir;
            if (g(y)->active)
                g(x)->emplace(g(y));
        }
}

void dfs(vertex* v, vertex* p) {
    v->vis = 1;
    for (auto u : v->e)
        if (u != p && !u->vis)
            dfs(u, v);
    if (p != nullptr)
        R.pb(v->pos, p->pos);
}

void odpal() {
    rep (i, 1, n)
        rep (j, 1, n)
            if (G[i][j].active) {
                dfs(&G[i][j], nullptr);
                return;
            }
}

auto solve() {
    char type;
    cin >> n >> type;
    rep (i, 1, n) {
        rep (j, 1, n) {
            char c;
            cin >> c;
            if (c != '.') {
                G[i][j].active = 1;
            }
        }
    }
    rep (i, 1, n) {
        rep (j, 1, n) {
            pii x{i,j};
            g(x)->pos = x;
            if (!g(x)->active) continue;
            G[n+1][n+1].emplace(g(x));
            switch (type) {
            case 'R':
                addDir(x, rookDir);
                break;
            case 'Q':
                addDir(x, rookDir);
                addDir(x, bishDir);
                break;
            case 'B':
                addDir(x, bishDir);
                break;
            case 'N':
                for (pii y : knigMov)
                    if (active(x+y))
                        g(x)->emplace(g(x+y));
                break;
            case 'K':
                for (pii y : kingMov)
                    if (active(x+y))
                        g(x)->emplace(g(x+y));
                break;
            }
        }
    }

    odpal();

    rep (i, 1, n)
        rep (j, 1, n)
            if (G[i][j].active && !G[i][j].vis) {
                cout << "NO" << endl;
                return nic;
            }

    cout << "YES" << endl;
    for (auto i : R)
        cout << i << endl;

    return nic;
}



int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int noOfTests = 1;
    //cin >> noOfTests;

    while(noOfTests --> 0)
        cout << solve() << '\n';

    return 0;
}