#include<bits/stdc++.h>

using namespace std;

#define ll long long

struct Trie{

    int nex[][],fail[],End[];

    int root,L;

    int newnode(){

        /*for(int i=0;i<26;i++)

            nex[L][i]=-1;*/

        End[L++]=;

        return L-;

    }

    int cnt;

    void init(){

        L=;

        cnt=;

        memset(nex,-,sizeof(nex));

        root=newnode();

    }

    void insert(char buf[]){

        int len=strlen(buf);

        int now=root;

        for(int i=;i<len;i++){

            int &t=nex[now][buf[i]-''];

            if(t==-)

                t=newnode();

            now=t;

        }

        End[now]++;

        cnt++;

    }

    void build(){

        queue<int>Q;

        fail[root]=root;

        for(int i=;i<;i++){

            if(nex[root][i]==-){

                nex[root][i]=root;

                //根节点没有对应的分支，还是必须回到根节点开始匹配

            }

            else{

                //根节点的后继失配，先假定回到根节点匹配

                fail[nex[root][i]]=root;

                Q.push(nex[root][i]);

            }

        }

        while(!Q.empty()){

            int now=Q.front();

            Q.pop();

            for(int i=;i<;i++)

                if(nex[now][i]==-){

                    //某个节点没有这个对应的分支，它失配了，沿着失配边去到最近的有这个分支的边？

                    nex[now][i]=nex[fail[now]][i];

                }

                else{

                    fail[nex[now][i]]=nex[fail[now]][i];

                    Q.push(nex[now][i]);

                    //如果这个节点的fail指针指向的点是End，那么因为这个节点蕴含他的fail节点，所以他也是End

                    End[now]|=End[fail[now]];

                }

        }

    }

    /*int query(char buf[]){

        int len=strlen(buf);

        int now=root;

        int res=0;

        for(int i=0;i<len;i++){

            now=nex[now][buf[i]-'0'];

            int temp=now;

            while(temp!=root&&End[temp]!=-1){

                res+=End[temp];

                End[temp]=-1;

                temp=fail[temp];

            }

            //if(res==cnt)

                //return res;

        }

        return res;

    }*/

    int vis[];

    int instack[];

    int find_circle(){

        memset(vis,,sizeof(vis));

        memset(vis,,sizeof(instack));

        return dfs(root);

    }

    int dfs(int id){

        instack[id]=;

        vis[id]=;

        for(int i=;i<;i++){

            if(instack[nex[id][i]]){

                //该节点的下一条边在dfs栈中，是反向边

                printf("TAK\n");

                exit();

            }

            if(vis[nex[id][i]]==){

                //不访问已经到过的表亲，表亲不可能成环

                if(End[nex[id][i]]==){

                    //下一个点不是病毒

                    dfs(nex[id][i]);

                }

            }

        }

        instack[id]=;

        return ;

    }

};

char buf[];

Trie ac;

int n;

void solve(){

    while(~scanf("%d",&n)){

        if(n==)

            break;

        ac.init();

        for(int i=;i<n;i++){

            scanf("%s",buf);

            ac.insert(buf);

        }

        ac.build();

        //scanf("%s",buf);

        if(ac.find_circle()==){

            cout<<"NIE"<<endl;

        }

    }

}

int main(){

#ifdef Yinku

    freopen("Yinku.in","r",stdin);

    //freopen("Yinku.out","w",stdout);

#endif // Yinku

    solve();

}