#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
#include <string>
#include <iostream>

using namespace std;

int compar(const char* a, const char* b) {
	return *a -*b;
}

int main() {
	int num;
	while (scanf("%d", &num) == 1) {
		vector<string> fielD;
		char field[26][27];
		std::string origrows[26], rows[26];

		int col_sets[26];
		memset(col_sets, 0, sizeof(col_sets));
		
		for (int i = 0; i<num;i++) {
			//char row[27];
			vector< string > vRow;
			string row;
			cin >> row;

			for (int j = 0; j < num; j++)
				col_sets[j] |= (1 << (row[j] - 'A'));

			//scanf("%s", row);
			fielD . push_back( row );
			//scanf("%s", field[i]);
			origrows[i] = row;
			sort( fielD[i] . begin(), fielD[i] . end() );
			//qsort(field[i], num, 1, (int (*)(const void*, const void*))compar);
			rows[i] = fielD[i];
		}

		/*for( int i = 0; i < num; i ++ )
		{
			cout << fielD[i];
			cout << endl;
		}*/

		string a(fielD[0]), b(fielD[1]), c(fielD[2]), correct;
		if (b == c)
			correct = c;
		else
			correct = a;
	
		int correct_col;
		if (col_sets[1] == col_sets[2])
			correct_col = col_sets[2];
		else
			correct_col = col_sets[0];
	
		int index = 0;
		for ( ; index < num; index++ ) {
			if( correct != rows[index] )
				break;
		}
		
		int col = 0;
		for (; col < num; col++) {
			if (col_sets[col] != correct_col) {
				//printf("%08X vs %08X\n",col_sets[col],correct_col);
				break;
			}
		}
		char ch;
		for( int i = 0; i < num; i ++ )
		{
			bool flag = false;
			
			for( int j = 0; j < num; j ++ )
				if( origrows[index][j] == correct[i] )
				{
					flag = true;
					break;
				}
			if( ! flag ) {
				ch = correct[i];
				break;
			}
		}
		
		/*for( int i = 0; i < num; i ++ )
		{
			for( int j = 0; j < num; j ++ )
			{
				if( rows[index]*/
		
		/*
		
		
		int badIndex = 0;
		int hashRemaining = 0;
			
		for( int i = 0; i < num; i ++ )
		{
			bool flag = false;
			
			for( int j = 0; j < num; j ++ )
				if( origrows[index][i] == correct[j] )
				{
					flag = true;
					hashRemaining += correct[j];
					break;
				}
			if( ! flag )
				badIndex = i;
		}
		
		int hashFull = 0;
		for( int i = 0; i < num; i ++ )
			hashFull += correct[i];
		
		char ch = hashFull - hashRemaining;
		
		if( ch < 26 )
			ch = origrows[index][badIndex] + ch;
		
		//printf( "%d %d %d\n", hashFull, hashRemaining, ch );
		
		/*int i = 0;
		for( ; i < num; i ++ )
			if( correct[i] != rows[index][i] )
				break;*/

		/*char badchar = rows[index][i];
		int badcol = 0;
		for(;badcol<num;badcol++)
		    if (origrows[index][badcol] == badchar)
				break;*/

		printf( "%d %d %c\n", index+1, col+1, ch );
		
	}
}