import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

/**
 * Created by cteam016 on 10/22/16.
 */
public class Tribune {

    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    static boolean solve(int n) throws IOException {
        String a;
        char [][] table = new char[n][n];

        for (int k = 0; k < n; k++){
            a  = br.readLine();
            for (int i = 0; i < a.length(); i++){
                table[k][i] = a.charAt(i);
            }
        }
        Set <Character> global = new HashSet<>();
        for (int k = 0; k < n; k++){
            global.add(table[0][k]);
        }
        Character[] ar = new Character[global.size()];
        global.toArray(ar);
        Arrays.sort(ar);
        String globalStr = "";
        for (int i = 0; i < ar.length; i++){
            globalStr += ar[i].charValue();
        }

        Set <Character> tmp = new HashSet<>();
        Character[] temp = new Character[global.size()];
        String tmpStr = "";

        // parse rows
        for (int k = 0; k < n ; k++){
            tmp.clear();
            tmpStr = "";
            for (int i = 0; i < n; i++){
                tmp.add(table[k][i]);
            }
            temp = new Character[tmp.size()];
            tmp.toArray(temp);
            Arrays.sort(temp);

            for (int i = 0; i < temp.length; i++){
                tmpStr += temp[i].charValue();
            }
            if (!tmp.equals(global)){
                if (k != 1) {
                    if (tmpStr.length() < globalStr.length()) {
                        // <<<<<
                        global.removeAll(tmp);
                        Character[] ch = new Character[2];
                        global.toArray(ch);
                        char out = ch[0].charValue();
                        // check
                        char[] toSort = new char[n];
                        for (int i = 0; i < n; i++) {
                            toSort[i] = table[k][i];
                        }
                        Arrays.sort(toSort);
                        char duplicate = '5';
                        for (int i = 0; i < n - 1; i++) {
                            if (toSort[i] == toSort[i + 1]) {
                                duplicate = toSort[i];
                            }
                        }
                        int b = -10;
                        int c = -10;
                        for (int i = 0; i < n; i++) {
                            if (table[k][i] == duplicate) {
                                if (b == -10) {
                                    b = i;
                                } else {
                                    if (c == -10) {
                                        c = i;
                                    }
                                }
                            }
                        }
                        Set<Character> bSet = new HashSet<>();
                        Set<Character> cSet = new HashSet<>();

                        for (int i = 0; i < n; i++) {
                            bSet.add(table[i][b]);
                            cSet.add(table[i][c]);
                        }
                        if (bSet.size() < cSet.size()) {
                            System.out.println((k + 1) + " " + (b + 1) + " " + out);
                            return true;
                        } else {
                            System.out.println((k + 1) + " " + (c + 1) + " " + out);
                            return true;
                        }
                    } else {
                        if (globalStr.length() < tmpStr.length()) {
                            // <<<<<
                            tmp.removeAll(global);
                            Character[] ch = new Character[2];
                            tmp.toArray(ch);
                            char out = ch[0].charValue();
                            // check
                            char[] toSort = new char[n];
                            for (int i = 0; i < n; i++) {
                                toSort[i] = table[k][i];
                            }
                            Arrays.sort(toSort);
                            char duplicate = '5';
                            for (int i = 0; i < n - 1; i++) {
                                if (toSort[i] == toSort[i + 1]) {
                                    duplicate = toSort[i];
                                }
                            }
                            int b = -10;
                            int c = -10;
                            for (int i = 0; i < n; i++) {
                                if (table[k][i] == duplicate) {
                                    if (b == -10) {
                                        b = i;
                                    } else {
                                        if (c == -10) {
                                            c = i;
                                        }
                                    }
                                }
                            }
                            Set<Character> bSet = new HashSet<>();
                            Set<Character> cSet = new HashSet<>();

                            for (int i = 0; i < n; i++) {
                                bSet.add(table[i][b]);
                                cSet.add(table[i][c]);
                            }
                            if (bSet.size() < cSet.size()) {
                                System.out.println((k + 1) + " " + (b + 1) + " " + out);
                                return true;
                            } else {
                                System.out.println((k + 1) + " " + (c + 1) + " " + out);
                                return true;
                            }
                        } else {
                            for (int i = 0; i < n; i++){
                                if (!global.contains(table[k][i])){
                                    global.removeAll(tmp);
                                    Character [] ch = new Character [2];
                                    global.toArray(ch);
                                    char out = ch[0].charValue();
                                    System.out.println((k + 1) + " " + (i + 1) + " " + out);
                                    return true;
                                }
                            }
                        }
                    }
                } else {
                    Set <Character> flag = new HashSet<>();
                    for (int i = 0; i < n; i++){
                        flag.add(table[k + 1][i]);
                    }
                    Character[] flagTmp = new Character[flag.size()];
                    String flagStr = "";
                    flag.toArray(flagTmp);
                    Arrays.sort(flagTmp);
                    for (int i = 0; i < flagTmp.length; i++){
                        flagStr += flagTmp[i].charValue();
                    }

                    if (flagStr.equals(globalStr)){
                        // 1st row fail

                        if (tmpStr.length() < globalStr.length()){
                            // <<<<<
                            global.removeAll(tmp);
                            Character [] ch = new Character [2];
                            global.toArray(ch);
                            char out = ch[0].charValue();
                            // check
                            char [] toSort = new char [n];
                            for (int i = 0; i < n; i++){
                                toSort[i] = table[1][i];
                            }
                            Arrays.sort(toSort);
                            char duplicate = '5';
                            for (int i = 0; i < n - 1; i++){
                                if (toSort[i] == toSort[i + 1]){
                                    duplicate = toSort[i];
                                }
                            }
                            int b = -10;
                            int c = -10;
                            for (int i = 0; i < n; i++){
                                if (table[1][i] == duplicate){
                                    if (b == - 10){
                                        b = i;
                                    } else {
                                        if (c == -10){
                                            c = i;
                                        }
                                    }
                                }
                            }
                            Set <Character> bSet = new HashSet<>();
                            Set <Character> cSet = new HashSet<>();
                            for (int i = 0; i < n; i++){
                                bSet.add(table[i][b]);
                                cSet.add(table[i][c]);
                            }
                            if (bSet.size() < cSet.size()){
                                System.out.println(2 + " " + (b + 1) + " " + out);
                                return true;
                            } else {
                                System.out.println(2 + " " + (c + 1) + " " + out);
                                return true;
                            }
                        } else {
                            if (globalStr.length() < tmpStr.length()){
                                // <<<<<
                                tmp.removeAll(global);
                                Character [] ch = new Character [2];
                                tmp.toArray(ch);
                                char out = ch[0].charValue();
                                // check
                                char [] toSort = new char [n];
                                for (int i = 0; i < n; i++){
                                    toSort[i] = table[1][i];
                                }
                                Arrays.sort(toSort);
                                char duplicate = '5';
                                for (int i = 0; i < n - 1; i++){
                                    if (toSort[i] == toSort[i + 1]){
                                        duplicate = toSort[i];
                                    }
                                }
                                int b = -10;
                                int c = -10;
                                for (int i = 0; i < n; i++){
                                    if (table[1][i] == duplicate){
                                        if (b == - 10){
                                            b = i;
                                        } else {
                                            if (c == -10){
                                                c = i;
                                            }
                                        }
                                    }
                                }
                                Set <Character> bSet = new HashSet<>();
                                Set <Character> cSet = new HashSet<>();

                                for (int i = 0; i < n; i++){
                                    bSet.add(table[i][b]);
                                    cSet.add(table[i][c]);
                                }
                                if (bSet.size() < cSet.size()){
                                    System.out.println(2 + " " + (b + 1) + " " + out);
                                    return true;
                                } else {
                                    System.out.println(2 + " " + (c + 1) + " " + out);
                                    return true;
                                }
                            } else {
                                for (int i = 0; i < n; i++){
                                    if (!global.contains(table[1][i])){
                                        global.removeAll(tmp);
                                        Character [] ch = new Character [2];
                                        global.toArray(ch);
                                        char out = ch[0].charValue();
                                        System.out.println(2 + " " + (i + 1) + " " + out);
                                        return true;
                                    }
                                }
                            }
                        }

                    } else {
                        //0nd row fail
                        if (tmpStr.length() < globalStr.length()){
                            // <<<<<<<
                            global.removeAll(tmp);
                            Character [] ch = new Character [2];
                            global.toArray(ch);
                            char out = ch[0].charValue();
                            // check
                            char [] toSort = new char [n];
                            for (int i = 0; i < n; i++){
                                toSort[i] = table[0][i];
                            }
                            Arrays.sort(toSort);
                            char duplicate = '5';
                            for (int i = 0; i < n - 1; i++){
                                if (toSort[i] == toSort[i + 1]){
                                    duplicate = toSort[i];
                                }
                            }
                            int b = -10;
                            int c = -10;
                            for (int i = 0; i < n; i++){
                                if (table[0][i] == duplicate){
                                    if (b == - 10){
                                        b = i;
                                    } else {
                                        if (c == -10){
                                            c = i;
                                        }
                                    }
                                }
                            }
                            Set <Character> bSet = new HashSet<>();
                            Set <Character> cSet = new HashSet<>();

                            for (int i = 0; i < n; i++){
                                bSet.add(table[i][b]);
                                cSet.add(table[i][c]);
                            }
                            if (bSet.size() < cSet.size()){
                                System.out.println(1 + " " + (b + 1) + " " + out);
                                return true;
                            } else {
                                System.out.println(1 + " " + (c + 1) + " " + out);
                                return true;
                            }

                        } else {
                            if (globalStr.length() < tmpStr.length()){
                                // <<<<<
                                tmp.removeAll(global);
                                Character [] ch = new Character [2];
                                tmp.toArray(ch);
                                char out = ch[0].charValue();
                                // check
                                char [] toSort = new char [n];
                                for (int i = 0; i < n; i++){
                                    toSort[i] = table[0][i];
                                }
                                Arrays.sort(toSort);
                                char duplicate = '5';
                                for (int i = 0; i < n - 1; i++){
                                    if (toSort[i] == toSort[i + 1]){
                                        duplicate = toSort[i];
                                    }
                                }
                                int b = -10;
                                int c = -10;
                                for (int i = 0; i < n; i++){
                                    if (table[0][i] == duplicate){
                                        if (b == - 10){
                                            b = i;
                                        } else {
                                            if (c == -10){
                                                c = i;
                                            }
                                        }
                                    }
                                }
                                Set <Character> bSet = new HashSet<>();
                                Set <Character> cSet = new HashSet<>();

                                for (int i = 0; i < n; i++){
                                    bSet.add(table[i][b]);
                                    cSet.add(table[i][c]);
                                }
                                if (bSet.size() < cSet.size()){
                                    System.out.println(1 + " " + (b + 1) + " " + out);
                                    return true;
                                } else {
                                    System.out.println(1 + " " + (c + 1) + " " + out);
                                    return true;
                                }
                            } else {
                                for (int i = 0; i < n; i++){
                                    if (!tmp.contains(table[0][i])){
                                        tmp.removeAll(global);
                                        Character [] ch = new Character [2];
                                        tmp.toArray(ch);
                                        char out = ch[0].charValue();
                                        System.out.println(1 + " " + (i + 1) + " " + out);
                                        return true;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        return true;
    }

    public static void main (String [] args) throws IOException {
        String st;
        boolean solved;
        while((st = br.readLine()) != null){
            int n;
            n = Integer.parseInt(st);
            solved = solve(n);
        }
    }
}