#include <iostream>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <queue>

using namespace std;
unordered_map<int, set<int> > graph;
unordered_map<int, pair<int,int>>  visited;
int N;
char ex_type;

unordered_set<int> visited_2;

void DFS(int v){
  for(auto n : graph[v]){
    if(!visited_2.count(n)){
      visited_2.insert(n);
      DFS(n);
      int i = n/N;
      int j = n%N;
      int i2 = v/N;
      int j2 = v%N;
      cout<<i+1<<" "<<j+1<<" "<<i2+1<<" "<<j2+1<<endl;
    }
  }
}

void BFS(){
  auto x = *graph.begin();
  queue<int> q;
  q.push(x.first);
  visited[x.first]={x.first,0};
  while(q.size()){
    int v = q.front(); q.pop();
    for(auto n : graph[v]){
      if(!visited.count(n)){
        visited[n]={v, visited[v].second + 1};
        q.push(n);
      }
    }
  }
}

void addEdge(int i1, int j1, int i2, int j2, vector<string> &board){
  if(i1<0 || i2 <0 || j1 < 0 || j2 < 0 || i1>N-1 || i2>N-1 || j1 >N-1 || j2>N-1) return;

  if(board[i2][j2] != ex_type) return;

  int k = i1*N+j1;
  int z = i2*N+j2;
  graph[k].insert(z);
  graph[z].insert(k);
}

void addKings(vector<string> &board){
  for(int i = 0; i < N; i++){
    for(int j = 0; j < N; j++){
      if(board[i][j]=='K'){
        addEdge(i,j,i-1,j, board);
        addEdge(i,j,i,j-1, board);
        addEdge(i,j,i+1,j, board);
        addEdge(i,j,i,j+1, board);

        addEdge(i,j,i-1,j-1, board);
        addEdge(i,j,i+1,j+1, board);
        addEdge(i,j,i-1,j+1, board);
        addEdge(i,j,i+1,j-1, board);
      }
    }
  }
}

void fillLine(vector<int> &found){
for( int k = 0; k < found.size(); k++){
  if(!graph.count(found[k])) graph[found[k]]=set<int>();
    for(int z = k+1; z < found.size(); z++){
      graph[found[k]].insert(found[z]);
      graph[found[z]].insert(found[k]);
    }
  }
}

void construct_graph(vector<string> &board){
  if(ex_type == 'R' || ex_type == 'Q'){
    vector<int> found;
    for(int i = 0; i < N; i++){
      found.clear();
      for(int j = 0; j < N; j++){
        if(board[i][j]==ex_type)
        found.push_back(i*N+j);
      }
      fillLine(found);
    }
    for(int j = 0; j < N; j++){
      found.clear();
      for(int i = 0; i < N; i++){
        if(board[i][j]==ex_type)
        found.push_back(i*N+j);
      }
      fillLine(found);
    }
  }
  if(ex_type == 'B' || ex_type == 'Q'){
    unordered_map<int, vector<int> > found;
    for(int i = 0; i < N; i++){
      for(int j = 0; j < N; j++){
        if(board[i][j]==ex_type)
          found[i+j].push_back(i*N+j);
      }
    }
    for(auto elem: found){
      fillLine(elem.second);
    }
    found.clear();
    for(int i = 0; i < N; i++){
      for(int j = 0; j < N; j++){
         if(board[i][j]==ex_type)
          found[i-j].push_back(i*N+j);
      }
    }
    for(auto elem: found){
      fillLine(elem.second);
    }
  }
  if(ex_type == 'K'){
    addKings(board);
  }

}


int main(){
  cin>>N;
  vector<string> board(N);

  cin >> ex_type;

  for(int i = 0; i< N; i++) cin>>board[i];


  construct_graph(board);
  BFS();
  if(visited.size() != graph.size()){
    cout<<"NO"<<endl;
    return 0;
  }
  cout<<"YES"<<endl;
  auto x = *graph.begin();
  visited_2.insert(x.first);
  DFS(x.first);

  return 0;
}