#include <iostream>
#include <vector>
#include <bitset>
#include <algorithm>
#include <tuple>

using namespace std;

constexpr int MAXN = 101;

char type;
int n;
int mat[MAXN][MAXN];
vector<tuple<int, int, int, int>> steps;
bitset<MAXN * MAXN> bio;

inline bool check(int i, int j) {
    return i >= 0 && i < n && j >= 0 && j < n;
}

void dfs(int i, int j);

inline void process(int a, int b, int c, int d) {
    if (!bio[c * n + d]) {
        steps.emplace_back(c, d, a, b);
        dfs(c, d);
    }
}

void horiz(int i, int j) {
    for (int k = 1; check(i + k, j); ++k) {
        if (mat[i + k][j] >= 0) {
            process(i, j, i + k, j);
        }
    }
    for (int k = 1; check(i - k, j); ++k) {
        if (mat[i - k][j] >= 0) {
            process(i, j, i - k, j);
        }
    }
    for (int k = 1; check(i, j + k); ++k) {
        if (mat[i][j + k] >= 0) {
            process(i, j, i, j + k);
        }
    }
    for (int k = 1; check(i, j - k); ++k) {
        if (mat[i][j - k] >= 0) {
            process(i, j, i, j - k);
        }
    }
}

void diag(int i, int j) {
    for (int k = 1; check(i + k, j + k); ++k) {
        if (mat[i + k][j + k] >= 0) {
            process(i, j, i + k, j + k);
        }
    }
    for (int k = 1; check(i - k, j + k); ++k) {
        if (mat[i - k][j + k] >= 0) {
            process(i, j, i - k, j + k);
        }
    }
    for (int k = 1; check(i + k, j - k); ++k) {
        if (mat[i + k][j - k] >= 0) {
            process(i, j, i + k, j - k);
        }
    }
    for (int k = 1; check(i - k, j - k); ++k) {
        if (mat[i - k][j - k] >= 0) {
            process(i, j, i - k, j - k);
        }
    }
}

void horse(int i, int j) {
    if (check(i + 2, j + 1) && mat[i + 2][j + 1] >= 0) {
        process(i, j, i + 2, j + 1);
    }
    if (check(i + 1, j + 2) && mat[i + 1][j + 2] >= 0) {
        process(i, j, i + 1, j + 2);
    }
    if (check(i - 2, j + 1) && mat[i - 2][j + 1] >= 0) {
        process(i, j, i - 2, j + 1);
    }
    if (check(i - 1, j + 2) && mat[i - 1][j + 2] >= 0) {
        process(i, j, i - 1, j + 2);
    }
    if (check(i + 2, j - 1) && mat[i + 2][j - 1] >= 0) {
        process(i, j, i + 2, j - 1);
    }
    if (check(i + 1, j - 2) && mat[i + 1][j - 2] >= 0) {
        process(i, j, i + 1, j - 2);
    }
    if (check(i - 2, j - 1) && mat[i - 2][j - 1] >= 0) {
        process(i, j, i - 2, j - 1);
    }
    if (check(i - 1, j - 2) && mat[i - 1][j - 2] >= 0) {
        process(i, j, i - 1, j - 2);
    }
}

void king(int i, int j) {
    for (int a = -1; a <= 1; ++a) for (int b = -1; b <= 1; ++b) {
        if ((a || b) && check(i + a, j + b) && mat[i + a][j + b] >= 0) {
            process(i, j, i + a, j + b);
        }
    }
}

void dfs(int i, int j) {
    bio.set(i * n + j);
    switch (type) {
    case 'R':
        horiz(i, j);
        break;
    case 'Q':
        horiz(i, j);
        diag(i, j);
        break;
    case 'B':
        diag(i, j);
        break;
    case 'N':
        horse(i, j);
        break;
    case 'K':
        king(i, j);
        break;
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    char c;
    int m = 0;

    cin>>n>>type;

    for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j) {
        cin>>c;
        if (c == type) {
            mat[i][j] = m;
            ++m;
        } else {
            mat[i][j] = -1;
        }
    }

    bool ok = false;
    for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j) if (mat[i][j] >= 0) {
        dfs(i, j);
        if (bio.count() == m) {
            ok = true;
        }
        break;
    }

    if (!ok) {
        cout<<"NO\n";
        return 0;
    }

    cout<<"YES\n";
    reverse(steps.begin(), steps.end());
    for (const auto& step: steps) {
        int a, b, c, d;
        tie(a, b, c, d) = step;
        cout<<a + 1<<' '<<b + 1<<' '<<c + 1<<' '<<d + 1<<"\n";
    }
}