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 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)

instructions = []
visited = []


def dfs_pop(vertex, pre=None):
    try:
        visited.append(vertex)
    except:
        if visited is None:
            while True:
                pass
        print("ERROR")
        exit(0)
    neighbours = graph[vertex]
    for neighbour in neighbours:
        if neighbour not in visited:
            dfs_pop(neighbour, pre=vertex)

    if pre is not None:
        instructions.append((vertex_to_original_position[vertex], vertex_to_original_position[pre]))


dfs_pop(0)
if len(visited) != num_of_vertices:
    print("NO")
else:
    print("YES")
    for ins in instructions:
        print(f"{ins[0][0] + 1} {ins[0][1] + 1} {ins[1][0] + 1} {ins[1][1] + 1}")