/* 
 * File:   main.cpp
 * Author: cteam045
 *
 * Created on October 22, 2016, 10:10 AM
 */

#include <cstdlib>
#include <cstdint>
#include <vector>
#include <iostream>
#include <map>
#include <set>

using namespace std;

struct StringId {
    StringId(int id, const string & str) : m_Id(id), m_Str(str) {}
    int m_Id;
    string m_Str;
    
};

void read(vector<StringId> & tribune, const uint32_t & num) {
    for (uint32_t i = 1; i <= num; i++) {
        string buffer;
        cin >> buffer;
        tribune.push_back(StringId(i, buffer));
    }
}

class Less {
  public:  
    bool operator() (const StringId & one, const StringId & two) {
        /*
        set<char> set_one;
        set<char> set_two;
        for (auto c : one.m_Str)
            set_one.insert(c);
        for (auto c : two.m_Str) 
            set_two.insert(c);
        if (set_one.size() != set_two.size())
            return true;
        for (auto c : set_one) {
            if (set_two.find(c) == set_two.end())
                return true;
        }
        return false;
         */
        
        set<char> set_one;
        for (auto c : one.m_Str)
            set_one.insert(c);
        //set<char> set_two;
        //for (auto c : two.m_Str)
        //    set_two.insert(c);
        //if (set_one.size() != set_two.size())
        //    return true;
        for (auto c : two.m_Str) {
            auto search = set_one.find(c);
            if (search == set_one.end())
                return true;
        }
         
        return false;
        
    }
};

void find_goodset(set<char> & good_set, vector<StringId> & tribune) {
    map<char, int> cmap;
    for (int i = 0; i < 3; i++) {
        for (char c : tribune[i].m_Str) {
            auto search = cmap.find(c);
            if (search == cmap.end())
                cmap.insert(make_pair(c, 1));
            else
                search -> second++;
        }
    }
    for (auto pair : cmap) {
        if (pair.second != 1 )
            good_set.insert(pair.first);
    }  
}

uint32_t find_rowid(set<char> & good_set, vector<StringId> & tribune) {
    for (auto sid : tribune) {
        set<char> row_set;
        for (auto c : sid.m_Str) {
            row_set.insert(c);
        }
        
        if (row_set != good_set)
            return sid.m_Id;
    }
    
    return 0;
}

/*
 * 
 */
int main() {
    uint32_t num = 0;
    while (cin >> num) {
        vector<StringId> tribune;
        read(tribune, num);
        /*
        for (auto sid : tribune)
            cout << sid.m_Id << ' ' << sid.m_Str << endl;
         */
        /*
        Less less;
        map<StringId, int, Less> teams(less);
        for (auto row : tribune) {
            //cout << row.m_Id << ' ' << row.m_Str << endl;
            
            auto search = teams.find(row);
            if (search == teams.end())
                teams.insert(make_pair(row, 1));
            else
                search -> second++;
        }
        */

        set<char> good_set;
        find_goodset(good_set, tribune);
        
        /*
        for (char c : good_set)
            cout << c;
        cout << endl; 
        */
        int row_id = find_rowid(good_set, tribune);
        string & bad_str = tribune[row_id - 1].m_Str;
        /*
        for (auto pair : teams) {
           cout << pair.first.m_Id << ' ' << pair.first.m_Str << endl;
           cout << pair.second << endl;
        }
        */
        
        /*
        auto sid_bad = teams.begin() -> first;
        int cnt_bad = teams.begin() -> second;
        auto sid_good = teams.rbegin() -> first;
        int cnt_good = teams.rbegin() -> second;
        
        if (cnt_bad > cnt_good) {
            
            auto tmp = sid_bad;
            sid_bad = sid_good;
            
            sid_good = tmp;
            
        }
        
        set<char> good_set;
        for (auto c : sid_good.m_Str) {
            good_set.insert(c);
        }
        */
        int column = 1;
        set<char> lets[tribune.size()];
        for (size_t j = 0; j < tribune.size(); j++) {
            for (size_t i = 0; i < tribune.size(); i++) {
                if (i == (size_t)row_id - 1)
                    continue;
                lets[j].insert(tribune[i].m_Str.at(j));
            }
        }
        
        
        /*
        for (size_t i = 0; i < tribune.size(); i++) {
            for (auto c : lets[i])
                cout << c;
            cout << endl;
        }
        */
        
        for (size_t i = 0; i < tribune.size(); i++) {
            auto search = lets[i].find(bad_str[i]);
            auto search_good = good_set.find(bad_str[i]);
            if (search != lets[i].end() || search_good == good_set.end()) {
                column = i + 1;
                break;
            }
        }
        map<char, int> cnt_let;
        for (auto c : good_set) {
            cnt_let.insert(make_pair(c,0));
        }
        for (auto c : bad_str) {
            auto search = cnt_let.find(c);
            if (search != cnt_let.end())
                search -> second++;
        }
        char symbol = '0';
        for (auto pair : cnt_let)
            if (pair.second == 0) {
                symbol = pair.first;
                break;
            }
        cout << row_id << ' ' << column << ' ' << symbol << endl;
        
    }
    return 0;
}