#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <bitset>		//UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <iomanip>		//do setprecision
#include <ctime>
#include <complex>
using namespace std;

#define FOR(i,b,e) for(int i=(b);i<(e);++i)
#define FORQ(i,b,e) for(int i=(b);i<=(e);++i)
#define FORD(i,b,e) for(int i=(b)-1;i>=(e);--i)
#define REP(x, n) for(int x = 0; x < (n); ++x)
#define ALL(u) (u).begin(),(u).end()

#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double

typedef pair<int, int> PII;

const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;

const int MR = 1e5 + 10;
const int MS = 500;
const int MK = 40010;
const int LIM = 2000;

const int p = 70032301;
const int q = 1000000007;


char buf[MS + 10];

int rh[MK];

// na jakich pozycjach wylosowalismy caly przedzial
int gdzie[LIM+10];
char allLetters[LIM + 10][MS + 10];

// dla wariantu ze znana dlugoscia, ktore litery mamy zapamietac
int los[MR];
char letters[MR];

inline bool getAllLetters(int ile)
{
	// spr czy jeszcze mozesz losowac - czy nie wybrano wszystkich dopuszczalnych pozycji
	// jesli tak, to losuj z prawd 1/20
	return ile < LIM && !(rand() % 20);
}

int pot[MS + 10];

int main()
{
	pot[0] = 1;
	FORQ(i, 1, MS)
		pot[i] = (pot[i - 1] * (LL)p) % q;

	srand((int)time(NULL));

	int n;
	scanf("%d", &n);

	if (n)
	{
		// znamy dlugosc

		if (n <= MR - 10)
		{
			scanf("%s", letters);

			int b = 0, e = n - 1;
			while (b < e)
			{
				if (letters[b] != letters[e])
				{
					printf("NIE\n");
					return 0;
				}
				b++;
				e--;
			}

			printf("TAK\n");

			return 0;
		}

		{
			// wylosuj 100K pozycji z pierwszej polowy
			int md = n / 2;
			REP(i, MR) los[i] = rand()*(LL)rand() % md;
			sort(los, los + MR);
		}

		int dl = 0, last = 0, cnt = 0, h = 0, ileh = 0;

		while (true)
		{
			memset(buf, 0, sizeof(buf));
			scanf("%500s", buf);

			int i = 0;
			while (true)
			{
				if (!buf[i])
					break;

				// zapisz litery, ktore masz sprawdzic
				while (last < MR && dl == los[last])
				{
					letters[cnt++] = buf[i];
					last++;
				}

				// jak jestes po drugiej stronie, to sprawdzaj czy odp litery sie zgadzaja
				while (last && dl == n - los[last - 1] - 1)
				{
					if (letters[--cnt] != buf[i])
					{
						printf("NIE\n");
						return 0;
					}

					last--;
				}

				h = (h*(LL)p + buf[i]) % q;

				// zwieksz dlugosc
				dl++;
				i++;
			}

			if (i)
			{
				// wylicz hasz w druga strone
				FORD(j, i, 0)
					rh[ileh] = (rh[ileh] * (LL)p + buf[j]) % q;

				// odznacz, ze policzylismy kolejny hasz
				ileh++;
			}

			if (i < MS)
				break;
		}

		// poskladaj caly rh
		FORD(i, ileh, 0)
			rh[i] = (rh[i] + rh[i + 1] * (LL)pot[MS]) % q;

		if (h != rh[0])
		{
			printf("NIE\n");
			return 0;
		}

		//wszystko jest ok, mamy palindrom
		printf("TAK\n");

		return 0;
	}

	// nie znamy dlugosci

	// wczytaj dane i licz hasze
	int
		dl = 0
		, ileh = 0
		, cnt = 0
		, lastd
		, ilep = 0
		, h = 0;

	while (true)
	{
		memset(buf, 0, sizeof(buf));
		scanf("%500s", buf);

		int i = 0;
		while (true)
		{
			if (!buf[i])
				break;

			h = (h*(LL)p + buf[i]) % q;

			if (dl < MR)
				los[dl] = buf[i];

			// zwieksz dlugosc
			dl++;
			i++;
		}

		lastd = i;

		if (i)
		{
			// zapamietaj ostatnia litere na przedziale
			letters[cnt++] = buf[i - 1];

			// zobacz, czy nie trzeba wyliczyc calego przedzialu, tylko jesli masz dlugosc calego przedzialu
			bool spr = 0;

			if (i == MS)
				spr = getAllLetters(ilep);

			// odznacz dlugosc, od ktorego mamy zapamietane litery na calym przedzial
			// dzieki temu sprawdzimy odp litere przy dowolnej reszcie na koncu
			if (spr)
				gdzie[ilep] = dl;

			FORD(j, i, 0)
			{
				rh[ileh] = (rh[ileh] * (LL)p + buf[j]) % q;
				if (spr)
					allLetters[ilep][j] = buf[j];
			}

			// odznacz, ze policzylismy kolejny hasz
			ileh++;

			// odznacz, jesli policzylismy kolejny przedzial
			if (spr)
				ilep++;
		}

		if (i < MS)
			break;
	}

	if (dl <= MR)
	{
		int b = 0, e = dl - 1;
		while (b < e)
		{
			if (los[b] != los[e])
			{
				printf("NIE\n");
				return 0;
			}
			b++;
			e--;
		}

		printf("TAK\n");

		return 0;
	}

	// lastd bedzie 0, jesli caly string dzieli sie przez MS, lub reszta z dzielenia
	//assert(lastd < MS);

	// wylicz indeks w all letters, ktora litere zawsze bedziemy brali
	int ind = lastd % MS;

	// do prawidlowego liczenia dlugosci jest potrzebna odp dlugosc ostatniego przedzialu
	// jesli bylo puste, to znaczy, ze calosc dzieli MS
	if (!lastd)
		lastd = MS;

	// zrekonstruuj caly rh i sprawdzaj zapisane litery
	// wylicz ile liter opuscilismy
	int suf = 0;
	FORD(i, ileh, 0)
	{
		rh[i] = (rh[i] + rh[i + 1] * (LL)pot[MS]) % q;

		if (ilep && dl == gdzie[ilep - 1])
		{
			// na tym przedziale mamy wszystkie litery wyliczone
			// odpowiedni indeks dostaniemy przez wyliczenie suf/MS
			// zawsze dokladamy cos (nawet cale MS) do suf i bierzemy tam litere
			// wiec mamy suf/MS + 1 blokow MS od konca
			// ale indeks od poczatku dla takiej liczby jest o 1 mniejszy
			// np pierwszy blok MS od poczatku jest zapisany w letters[0]
			// tam jest ostatnia litera z pierwszego bloku, pod pozycja MS-1

			if (letters[suf / MS] != allLetters[ilep - 1][ind])
			{
				printf("NIE\n");
				return 0;
			}

			ilep--;
		}


		dl -= lastd;
		suf += lastd;

		// wszedzie poza ostatnia dlugoscia lastd = MS
		lastd = MS;
	}

	if (h != rh[0])
	{
		printf("NIE\n");
		return 0;
	}

	//wszystko jest ok, mamy palindrom
	printf("TAK\n");

	return 0;
}