first = input().strip().split()
n = int(first[0])
type = first[1]

vertex_to_original_position = []
original_position_to_vertex = []
for i in range(n):
    original_position_to_vertex.append([])
    for j in range(n):
        original_position_to_vertex[i].append(None)


def make_edge(x0, y0, x1, y1):
    if x1 < 0 or x1 >= n or y1 < 0 or y1 >= n:
        return
    if grid[x1][y1] == '.':
        return
    v1 = original_position_to_vertex[x0][y0]
    v2 = original_position_to_vertex[x1][y1]
    graph[v1].append(v2)


def fill_horizontal(x, y):
    for i in range(n):
        if i != x:
            make_edge(x, y, i, y)


def fill_vertical(x, y):
    for i in range(n):
        if i != y:
            make_edge(x, y, x, i)


def fill_back_diagonal(x, y):
    d1 = min(x, n - 1 - y)
    for i in range(n - d1):
        make_edge(x, y, x - i, y + i)
    d2 = min(n - 1 - x, y)
    for i in range(n - d2):
        make_edge(x, y, x + i, y - i)


def fill_front_diagonal(x, y):
    larger = max(x, y)
    for i in range(n - larger):
        make_edge(x, y, x + i, y + i)
    smaller = min(x, y)
    for i in range(smaller):
        make_edge(x, y, x - i, y - i)


def fill_horse(x, y):
    make_edge(x, y, x + 2, y + 1)
    make_edge(x, y, x + 2, y - 1)
    make_edge(x, y, x - 2, y + 1)
    make_edge(x, y, x - 2, y - 1)
    make_edge(x, y, x + 1, y + 2)
    make_edge(x, y, x + 1, y - 2)
    make_edge(x, y, x - 1, y + 2)
    make_edge(x, y, x - 1, y - 2)


def fill_one_step(x, y):
    make_edge(x, y, x - 1, y)
    make_edge(x, y, x, y - 1)
    make_edge(x, y, x + 1, y)
    make_edge(x, y, x, y + 1)
    make_edge(x, y, x - 1, y - 1)
    make_edge(x, y, x + 1, y - 1)
    make_edge(x, y, x + 1, y + 1)
    make_edge(x, y, x - 1, y + 1)


def make_graph_R(x, y):
    fill_horizontal(x, y)
    fill_vertical(x, y)


def make_graph_Q(x, y):
    fill_horizontal(x, y)
    fill_vertical(x, y)
    fill_front_diagonal(x, y)
    fill_back_diagonal(x, y)


def make_graph_B(x, y):
    fill_front_diagonal(x, y)
    fill_back_diagonal(x, y)


def make_graph_N(x, y):
    fill_horse(x, y)


def make_graph_K(x, y):
    fill_one_step(x, y)


def hamiltonian_path(G, size, pt, path=[]):
    if pt not in set(path):
        path.append(pt)
        if len(path) == size:
            return path
        for pt_next in G[pt]:
            res_path = [i for i in path]
            candidate = hamiltonian_path(G, size, pt_next, res_path)
            if candidate is not None:  # skip loop or dead end
                return candidate


def make_graph(t):
    v = 0
    func = None
    if type == "R":
        func = lambda x, y: make_graph_R(x, y)
    elif type == "Q":
        func = lambda x, y: make_graph_Q(x, y)
    elif type == "B":
        func = lambda x, y: make_graph_B(x, y)
    elif type == "N":
        func = lambda x, y: make_graph_N(x, y)
    elif type == "K":
        func = lambda x, y: make_graph_K(x, y)

    for i in range(n):
        for j in range(n):
            if grid[i][j] != '.':
                vertex_to_original_position.append((i, j))
                original_position_to_vertex[i][j] = v
                v += 1

    for i in range(n):
        for j in range(n):
            if grid[i][j] != '.':
                func(i, j)


grid = []
graph = []
num_of_vertices = 0
for i in range(n):
    line = input().strip()
    row = []
    for c in line:
        row.append(c)
        if c == type:
            num_of_vertices += 1
    grid.append(row)

for i in range(num_of_vertices):
    graph.append([])

make_graph(type)
#print(original_position_to_vertex)
#print(vertex_to_original_position)
#print(graph)
path = hamiltonian_path(graph, num_of_vertices, 0)
if path is None:
    print("NO")
else:
    print("YES")
    for i in range(num_of_vertices - 1):
        coords_1 = vertex_to_original_position[path[i]]
        coords_2 = vertex_to_original_position[path[i + 1]]
        print(f"{coords_1[0] + 1} {coords_1[1] + 1} {coords_2[0] + 1} {coords_2[1] + 1}")