#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <math.h>
#include <queue>
#include <set>

using namespace std;
using ll = long long;

struct vertex {
    int left = -1;
    int right = -1;
    bool leaf = 0;
    int p = -1;
    int pch = 0;
    int link = -1;
    int go[2];
    vertex(){
        go[0] = go[1] = -1;
    }
};

vector<vector<int>> g;
vector<vertex> gr;

void add_string(const string & s) {
    int v = 0;
    for (int i = 0; i < s.size(); ++i) {
        if (s[i] == '1') {
            if (gr[v].right == -1) {
                vertex new_vert;
                new_vert.p = v;
                new_vert.pch = 1;
                gr.push_back(new_vert);
                gr[v].right = gr.size() - 1;
            }
        } else if (gr[v].left == -1) {
            vertex new_vert;
            new_vert.p = v;
            new_vert.pch = 0;
            gr.push_back(new_vert);
            gr[v].left = gr.size() - 1;
        }
        if (s[i] == '1') {
            v = gr[v].right;
        } else {
            v = gr[v].left;
        }
    }
    if (s.size() > 0) {
        gr[v].leaf = true;
    }
}

int go (int v, int c);

int get_link (int v) {
    if (gr[v].link == -1) {
        if (v == 0 || gr[v].p == 0) {
            gr[v].link = 0;
        } else {
            gr[v].link = go(get_link(gr[v].p), gr[v].pch);
        }
    }
    if (v != 0) {
        g[gr[v].link].push_back(v);
    }
    return gr[v].link;
}

int go (int v, int c) {
    if (gr[v].go[c] == -1) {
        if (c == 0 && gr[v].left != -1) {
            gr[v].go[c] = gr[v].left;
        } else if (c == 1 && gr[v].right != -1) {
            gr[v].go[c] = gr[v].right;
        } else {
            if (!v) {
                gr[v].go[c] = 0;
            } else {
                gr[v].go[c] = go(get_link(v), c);
            }
        }
    }
    return gr[v].go[c];
}

const int MAXN = 1e5 + 1488;

bool used[MAXN];

void BFS() {
    queue<int> q;
    g.resize(gr.size());
    for (int i = 0; i < gr.size(); ++i) {
        int tmp = get_link(i);
        if (gr[i].leaf) {
            used[i] = true;
            q.push(i);
        }
    }
    while (!q.empty()) {
        int cur = q.front();
        q.pop();
        for (int i = 0; i < g[cur].size(); ++i) {
            int to = g[cur][i];
            if (!used[to]) {
                q.push(to);
                used[to] = 1;
                gr[to].leaf = 1;
            }
        }
    }
}

int usedd[MAXN];

void DFS(int v);

void DFS_SON(int son) {
    if (son != -1) {
        if (usedd[son] == 1) {
            cout << "TAK";
            exit(0);
        }
        if (!usedd[son]) {
            DFS(son);
        }
    }
}

void DFS(int v) {
    if (gr[v].leaf) {
        usedd[v] = 2;
        return;
    }
    usedd[v] = 1;
    int rson = gr[v].right;
    DFS_SON(rson);
    int lson = gr[v].left;
    DFS_SON(lson);
    usedd[v] = 2;
}

int main() {
    int n;
    cin >> n;
    vertex root;
    gr = {root};
    for (int i = 0; i < n; ++i) {
        string s;
        cin >> s;
        add_string(s);
    }
    BFS();
    for (int i = 0; i < gr.size(); ++i) {
        int pr = gr[i].left * gr[i].right;
        if (pr) {
            if (gr[i].right == -1) {
                gr[i].right = go(i, 1);
            }
            if (gr[i].left == -1) {
                gr[i].left = go(i, 0);
            }
        }
    }
    DFS(0);
    cout << "NIE";
    return 0;
}