import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
import java.util.stream.Collectors;

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

    public static void main(String[] args)  {

        Scanner scanner = new Scanner(System.in);

        // write your code here

        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        String nrS;
        try {
            do {
                ArrayList<String> gr = new ArrayList<>();
                ArrayList<char[]> chars = new ArrayList<>();
                nrS= bufferedReader.readLine();
                int n = Integer.parseInt(nrS);
                char wrong;

                for (int i= 0; i < n; i++)
                {
                    String l = bufferedReader.readLine();
                    gr.add(l);
                    char[] line = l.toCharArray();
                    Arrays.sort(line);
                    chars.add(line);


                    //System.out.println(line);
                    //System.out.println(l);
                }

                char[] correct = findCorrect(chars);
                char bad = 0;
                char good = 0;
                for (int i = 0; i < n; i++) {
                   if (!Arrays.equals(chars.get(i), correct))
                   {
                       Set<Character> s = uniques(gr.get(i),new String(correct));
                       for (char c :s)
                       {
                           bad = c;
                           break;

                       }
                       Set<Character> g = uniques(new String(correct),gr.get(i));
                       for (char c :g)
                       {
                           good = c;
                           break;

                       }
                       System.out.println((i+1)+" "+(gr.get(i).indexOf(bad)+1)+" "+good);
                       break;
                   }
                }
                /*

                //int bad = -1;
                char bad = 0;
                int badLine = -1;
                char bad2 = 0;
                char realyBad = 0;
                for (int i = 1; i < n; i ++) {
                    if (!chars.get(i).equals(chars.get(i-1)))
                    {

                        char last = chars.get(i)[0];
                        for (int j = 1; j < n; j++) {
                            if (last == chars.get(i)[j])
                            {
                                badLine = j;

                                bad = last;
                                break;
                            }
                            if (last == chars.get(i-1)[j])
                            {
                                badLine = j;
                                bad = last;
                                break;
                            }
                        }
                        if (bad != 0)
                            break;

                        Set<Character> s = uniques(gr.get(i),gr.get(i-1));
                        Set<Character> s2 = uniques(gr.get(i-1),gr.get(i));

                        for (char c :s)
                        {
                            System.out.println("t2 "+c);
                            bad = c;
                            break;

                        }
                        for (char c :s2)
                        {
                            System.out.println("t3 "+c);
                            bad2 = c;
                            break;

                        }

                        //break;
                    }

                }

                if (badLine != -1)
                {

                }

                int b1 = 0;
                int b2 = 0;
                int badRow = 0;
                if (realyBad == 0) {
                    for (int i = 0; i < n; i++) {
                        if (gr.get(i).contains("" + bad))
                            b1++;

                        if (gr.get(i).contains("" + bad2))
                            b2++;
                        if (b1 > 1) {
                            realyBad = bad2;
                            break;
                        }
                        if (b2 > 1) {
                            realyBad = bad;
                            break;
                        }
                    }

                }
                for (int i = 0; i < n; i++) {
                    int index = gr.get(i).indexOf(realyBad);

                    if (index != -1)
                    {
                        char correct = 0;

                        Set<Character> g = uniques(new String(chars.get(0)),gr.get(i));
                        for (char c : g)
                        {
                            System.out.println((badi+1)+" "+(index+1)+" "+c);
                            break;
                        }
                        break;
                    }/*
                        continue;

                    for (int j = 0; j <n; j++)
                    {
                        int nr = 0;
                        int index = -1;
                        for (int k = 0; k < n; k++) {
                            if (gr.get(bad).charAt(k) == chars.get(i)[j]) {
                                nr++;
                                if (index == -1)
                                    index = k;
                            }
                        }
                        if (nr > 1 || nr == 0)
                        {
                            if (index==-1) index = 0;
                            correct = chars.get(i)[j];
                            System.out.println((bad+1)+" "+(index+1)+" "+correct);
                            break;
                        }

                    }
                    /*
                    break;

                }*/
//                System.out.println();

            }
            while(nrS != null);
        } catch (Exception e) {
            //
        }

    }

    private static char[] findCorrect(ArrayList<char[]> chars) {
        /*char[] line = new char[chars.get(0).length];
        for (int i = 0; i < line.length;i++)
            line[i] = chars.get(0)[i];*/
        char[] line = chars.get(0);
        for (int i = 1; i < chars.size(); i++)
        {
            if (line.equals(chars.get(i)))
                return line;
            if (i == 2)
                return chars.get(i);
        }
        return line;
    }

    private static Set<Character> uniques(String first, String second) {
        Set<Character> a = first.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
        Set<Character> b = second.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
        a.removeAll(b);
        return a;
    }

}