try:
    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 = set()


    def dfs_pop(vertex, pre=None):
        if vertex >= len(graph):
            return
        visited.add(vertex)
        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]))


    if len(graph[0]) == 0:
        print("NO")
        exit(0)
    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}")
    #
    # 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]}")
except:
    print("NO")