#include <iostream>
#include <vector>

struct Excavator {
    int x, y;
    int parent = -1;
};

int N;
char type;

int main() {
    std::vector<Excavator> excavators = {};
    std::vector<std::vector<int>> neighbors = {};
    std::cin >> N >> type;

    bool (* areNeighbors)(Excavator, Excavator);
    switch (type) {
        case 'R':
            areNeighbors = [](Excavator a, Excavator b) {
                return a.x == b.x || a.y == b.y;
            };
            break;
        case 'Q':
            areNeighbors = [](Excavator a, Excavator b) {
                return a.x == b.x || a.y == b.y || a.x + a.y == b.x + b.y || a.x - a.y == b.x - b.y;
            };
            break;
        case 'B':
            areNeighbors = [](Excavator a, Excavator b) {
                return a.x + a.y == b.x + b.y || a.x - a.y == b.x - b.y;
            };
            break;
        case 'N':
            areNeighbors = [](Excavator a, Excavator b) {
                return (abs(a.x - b.x) == 2 && abs(a.y - b.y) == 1) || (abs(a.y - b.y) == 2 && abs(a.x - b.x) == 1);
            };
            break;
        case 'K':
            areNeighbors = [](Excavator a, Excavator b) {
                return (a.x == b.x && abs(a.y - b.y) == 1) || (a.y == b.y && abs(a.x - b.x) == 1) ||
                       (abs(a.x - b.x) == 1 && abs(a.y - b.y) == 1);
            };
            break;
    }

    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            char c;
            std::cin >> c;
            if (c != '.') {
                Excavator excavator = {.x =  i, .y =  j};
                int E = excavators.size();
                std::vector<int> newNeighbors = {};
                for (int k = 0; k < E; ++k) {
                    if (areNeighbors(excavator, excavators.at(k))) {
                        neighbors.at(k).push_back(E);
                        newNeighbors.push_back(k);
                    }
                }
                excavators.push_back(excavator);
                neighbors.push_back(newNeighbors);
            }
        }
    }

    std::vector<int> visitedElements(excavators.size());
    visitedElements[0] = 0;
    excavators[0].parent = -2;
    int numberOfVisited = 1;
    int activeElement = 0;
    while (activeElement != numberOfVisited) {
        for (int i = 0; i < neighbors[visitedElements[activeElement]].size(); ++i) {
            int index = neighbors[visitedElements[activeElement]][i];
            if (excavators[index].parent == -1) {
                visitedElements[numberOfVisited] = index;
                numberOfVisited++;
                excavators[index].parent = visitedElements[activeElement];
            }
        }
        activeElement++;
    }

    if (numberOfVisited < excavators.size()) {
        std::cout << "NO" << std::endl;
    } else {
        std::cout << "YES" << std::endl;
        for (int i = numberOfVisited - 1; i > 0; --i) {
            Excavator e1 = excavators[visitedElements[i]];
            Excavator e2 = excavators[e1.parent];
            std::cout << (e1.x + 1) << " " << (e1.y + 1) << " " << (e2.x + 1) << " " << (e2.y + 1) << std::endl;
        }
    }

    return 0;
}