#include <bits/stdc++.h>

using namespace std;

using ii = pair<int,int>;
using vi = vector<int>;

const int dx[] = { 0, 1, 0, -1, 1, -1, -1, 1 };
const int dy[] = { 1, 0, -1, 0, 1, -1, 1, -1 };

const int kx[] = { -2, -1, -1, -2, 2, 1, 2, 1 };
const int ky[] = { -1, -2, 2, 1, -1, -2, 1, 2 };

char A[100][100];
vector<ii> AX;
vector<vi> vex;
vi E;
int V[10000];

int indx(int i, int j) { return lower_bound(AX.begin(), AX.end(), ii{ i, j }) - AX.begin(); }

int n; 
int ok(int i, int j) { return (i > -1) && (i < n) && (j > -1) && (j < n) && (A[i][j] != '.'); }

void dfs(int i) {
	E[i] = 1;
	for (int x: vex[i])
		if (!E[x])
			dfs(x);

	return ;
}

int main() {
	cin.tie(NULL) -> sync_with_stdio(false);
    
	char c;
	cin >> n >> c;
	for (int i = 0; i < n; ++i)
		for (int j = 0; j < n; ++j) {
			cin >> A[i][j];
			if (A[i][j] != '.')
				AX.emplace_back(i, j);
		}

	vex.resize(AX.size());

	for (int i = 0; i < n; ++i)
		for (int j = 0; j < n; ++j)
			if (A[i][j] != '.') {
				int id = indx(i, j);
				switch (c) {
				case 'K':
					for (int k = 0; k < 8; ++k) {
						int x = i + dx[k];
						int y = j + dy[k];
						if (ok(x, y))
							vex[id].push_back(indx(x, y));
					}
					break;
				case 'N':
					for (int k = 0; k < 8; ++k) {
						int x = i + kx[k];
						int y = j + ky[k];
						if (ok(x, y))
							vex[id].push_back(indx(x, y));
					}
					break;

				case 'B':
					for (int k = 4; k < 8; ++k)
						for (int d = 1; d < n; ++d) {
							int x = d * dx[k] + i;
							int y = d * dy[k] + j;
							if (ok(x, y)) {
								vex[id].push_back(indx(x, y));
							}
						}
					break;
                    
				case 'Q':
					for (int k = 0; k < 8; ++k)
						for (int d = 1; d < n; ++d) {
							int x = d * dx[k] + i;
							int y = d * dy[k] + j;
							if (ok(x, y)) {
								vex[id].push_back(indx(x, y));
							}
						}
					break;

				case 'R':
					for (int k = 0; k < 4; ++k)
						for (int d = 1; d < n; ++d) {
							int x = d * dx[k] + i;
							int y = d * dy[k] + j;
							if (ok(x, y)) {
								vex[id].push_back(indx(x, y));
							}
						}
				}
    
			}
    
	E.resize(AX.size());
	dfs(0);
	if (accumulate(E.begin(), E.end(), 0) < AX.size()) {
		cout << "NO";
		return 0;
	}

	for (int &x: E)
		x = 0;
    
	stack<int> box;
	vector<tuple<int,int,int,int>> res;
    
	for (int i = 0; i < vex.size(); ++i) {
		V[i] = vex[i].size();
		if (V[i] == 1)
			box.push(i);
	}

	int d = 0;
	while (1) {
		int u = d;
		while (box.size() && E[box.top()])
			box.pop();
        
		if (box.size()) {
			u = box.top();
			box.pop();
		} else {
			while (d < AX.size() && E[d])
				d += 1;
			u = d;
		}
		if (d == AX.size())
			break;

		E[u] = 1;
        
		int v = -1;
		for (int i: vex[u])
			if (!E[i]) {
				v = i;
				V[i] -= 1;
				if (V[i] == 1)
					box.push(i);
			}

		if (v != -1)
			res.emplace_back(AX[u].first, AX[u].second, AX[v].first, AX[v].second);
	}
    

	cout << "YES\n";
	for (auto [a, b, c, d]: res)
		cout << a + 1 << ' ' << b + 1 << ' ' << c + 1 << ' ' << d + 1 << '\n';
    
	return 0;
}