#include <iostream>
#include <vector>
#include <tuple>
#include <math.h>
#include <stdio.h>

using namespace std;
int N;
char type;
vector<vector<int>> graph;
vector<tuple<int, int>> final_path;
vector<tuple<int, int>> positions;
vector<vector<int>> neighbours;

bool is_reachable(tuple<int, int> a, tuple<int, int> b) {
    bool ret;
    switch (type) {
        case 'R':
            ret = get<0>(a) == get<0>(b) || get<1>(a) == get<1>(b);
            break;
        case 'Q':
            // horizontal lines
            ret = abs(get<0>(a) - get<0>(b)) == abs(get<1>(a) - get<1>(b)) || get<0>(a) == get<0>(b) ||
                  get<1>(a) == get<1>(b);
            break;
        case 'B':
            ret = abs(get<0>(a) - get<0>(b)) == abs(get<1>(a) - get<1>(b));
            break;
        case 'K':
            ret = abs(get<0>(a) - get<0>(b)) == 1 || abs(get<1>(a) - get<1>(b)) == 1;
            break;
        default:
            ret = (abs(get<0>(a) - get<0>(b)) == 2 && abs(get<1>(a) - get<1>(b)) == 1) ||
                  (abs(get<0>(a) - get<0>(b)) == 1 && abs(get<1>(a) - get<1>(b)) == 2);
    }
    return ret;
}

vector<vector<int>> get_graph(const vector<tuple<int, int>>& nodes) {

    neighbours.reserve(N);
    for (int i = 0; i < N; ++i)
        neighbours.emplace_back(vector<int>());
    for (int i = 0; i < N; ++i) {
        vector<int> list;
        for(int j = i + 1; j<N; ++j){
            if (is_reachable(nodes.at(i), nodes.at(j))){
                neighbours.at(j).push_back(i);
                neighbours.at(i).push_back(j);
            }
        }
    }
    return neighbours;
}


//def rec(graph, is_kept, path):
//    for i in range(N):
//        if is_kept[i]:
//        is_kept[i] = false;
//        for j in graph[i]:
//            path.append([i,j])
//            rec(deepcopy(graph), deepcopy(is_kept), deepcopy(path))
bool recursion(vector<bool> is_alive, vector<tuple<int, int>> path){
//    for (bool a:is_alive)
//        printf("%d ", a);
//    printf("\n");
//    for (tuple<int, int> p:path)
//        printf("(%d %d) ", get<0>(p),get<1>(p));
//    printf("\n");
    bool ret;
    if (path.size() == N-1) {
        final_path = path;
        return true;
    }
    for (int i = 0; i<N; ++i){
        if (is_alive.at(i)){
            is_alive.at(i) = false;
            for (int j:neighbours.at(i)){
                if (is_alive.at(j)){
                    path.push_back(tuple<int, int>(i, j));
                    ret = recursion(is_alive, path);
                    if (ret)
                        return ret;
                    path.pop_back();
                }
            }

            is_alive.at(i) = true;
        }
    }
//    printf("backtracking \n");
    return false;
}
void print_solution(){
    if(final_path.size() == N-1){
        printf("YES\n");
        for(tuple<int, int> a : final_path){
            printf("%d %d %d %d\n", get<0>(positions.at(get<0>(a))),
                                    get<1>(positions.at(get<0>(a))),
                                    get<0>(positions.at(get<1>(a))),
                                    get<1>(positions.at(get<1>(a))));
        }
    } else {
        printf("NO\n");
    }

}

int main() {
    char c;
    scanf("%d %c\n", &N, &type);

    for (int i = 1; i <= N; ++i) {
        for (int j = 1; j <= N; ++j) {
            scanf("%c", &c);
            if (c != '.')
                positions.emplace_back(i, j);
        }
        scanf("%c", &c);
    }
    N = positions.size();

//    for (tuple<int, int> a: positions)
//        printf("%d %d\n", get<0>(a), get<1>(a));
//    printf("N %d\n", N);

    get_graph(positions);

    vector<bool> is_alive;
    for (int i = 0; i<N; ++i)
        is_alive.push_back(true);
//    printf("init\n");
    recursion(is_alive, vector<tuple<int, int>>());
//    printf("recursion\n");

//    for(auto p: final_path)
//        cout << "("<< get<0>(p) << " " << get<1>(p) << ") ";
//    printf("\n");
    print_solution();

    return 0;
}