Problem:
Look for the Winner!

The citizens of TKB City are famous for their deep love in elections and vote counting.
Today they hold an election for the next chairperson of the electoral commission.
Now the voting has just been closed and the counting is going to start.
The TKB citizens have strong desire to know the winner as early as possible during vote counting.

The election candidate receiving the most votes shall be the next chairperson.
Suppose for instance that we have three candidates A, B, and C and ten votes.
Suppose also that we have already counted six of the ten votes and the vote counts of A, B, and C are four, one, and one, respectively.
At this moment, every candidate has a chance to receive four more votes and so everyone can still be the winner.
However, if the next vote counted is cast for A, A is ensured to be the winner since A already has five votes and B or C can have at most four votes at the end.
In this example, therefore, the TKB citizens can know the winner just when the seventh vote is counted.

Your mission is to write a program that receives every vote counted, one by one, identifies the winner, and determines when the winner gets ensured.

Input

The input consists of at most 1500 datasets, each consisting of two lines in the following format.

n

c1 c2 … cn

n in the first line represents the number of votes, and is a positive integer no greater than 100.
The second line represents the n votes, separated by a space.
Each ci (1 ≤ i ≤ n) is a single uppercase letter, i.e. one of 'A' through 'Z'.
This represents the election candidate for which the i-th vote was cast.
Counting shall be done in the given order from c1 to cn.

You should assume that at least two stand as candidates even when all the votes are cast for one candidate.

The end of the input is indicated by a line containing a zero.

Output

For each dataset, unless the election ends in a tie, output a single line containing an uppercase letter c and an integer d separated by a space:
c should represent the election winner and d should represent after counting how many votes the winner is identified.
Otherwise, that is, if the election ends in a tie, output a single line containing `TIE'.

Sample Input

1
A
4
A A B B
5
L M N L N
6
K K K K K K
6
X X X Y Z X
10
A A A B A C A C C B
10
U U U U U V V W W W
0

Output for the Sample Input

A 1
TIE
TIE
K 4
X 5
A 7
U 8

Solution in Rust (judge verdict: Accepted)

use std::io::{stdin, Read, StdinLock};
use std::str::FromStr;
use std::collections::{BTreeMap};
use std::cmp;
use std::mem;

struct Scanner<'a> {
    cin : StdinLock<'a>,
}

impl<'a> Scanner<'a> {
    fn new(cin : StdinLock<'a>) -> Scanner<'a> {
        Scanner { cin: cin }
    }

    fn read1<T: FromStr>(&mut self) -> Option<T> {
        let token = self.cin.by_ref().bytes().map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect::<String>();
        token.parse::<T>().ok()
    }

    fn read<T: FromStr>(&mut self) -> T {
        self.read1().unwrap()
    }
}

fn calc(n: i32, l: &[char], s: &mut BTreeMap<char, i32>) -> Option<(char, i32)> {
    let (ls, lr) = l.split_first().unwrap();
    *s.entry(*ls).or_insert(0) += 1;
    let mut first = ('*', 0);
    let mut second = ('*', 0);
    /* aoj の rustc 1.17だからfor_each ないんだって
     * 悲しいね
    s.iter().for_each(|(k,v)| {
        if second.1 <= *v { second = (*k,*v); }
        if first.1 < second.1 { mem::swap(&mut first, &mut second); }
    });
    */
    for (k,v) in s.iter() {
        if second.1 <= *v { second = (*k,*v); }
        if first.1 < second.1 { mem::swap(&mut first, &mut second); }
    }
    if second.1 + n < first.1 { Some((first.0, n)) }
    else { 
        if n == 0 { None }
        else { calc(n-1, lr, s) }
    }
}


fn main(){
	let cin = stdin();
	let cin = cin.lock();
	let mut sc = Scanner::new(cin);
    loop{
        let n : i32 = sc.read();
        if n == 0 { break; }
        let mut k = Vec::<char>::new();
        // aoj のバージョンだとcharがFromStrにimplementされてないよ
        for _ in 0..n { k.push(sc.read::<String>().chars().next().unwrap()); }
        let mut m = BTreeMap::<char, i32>::new();
        m.insert('*',0);
        if let Some((c, d)) = calc(n-1, k.as_slice(), &mut m){
            println!("{} {}", c, n-d);
        } else {
            println!("TIE");
        }
    }
}