#include <iostream>

using namespace std;

const int LETTERS='z'-'a'+1;
const int READ_BUF=1024;
char buf[READ_BUF+2];

class Hash {
private:
    const int p;
    const int d;
    int hash;
    int h;

public:
    Hash(int p, char s, int d=LETTERS) : p(p), d(d), hash(s % p), h(1) {
    }
public:
    inline void push_back(char c) {
        h=(h*d)%p;
        hash=(hash*d + c)%p;
    }

    inline void push_front(char c)  {
        h=(h*d)%p;
        hash=(hash + c*h)%p;
    }

    inline void update_front_push_back(char old, char c) {
        const int prev=(hash + p - (old*h)%p)%p;
        hash = (prev * d + c) % p;
    }

    inline int code() const { return hash; }

    inline bool equals(const Hash& o) {
        return hash==o.hash;
    }
};

enum {
    HASH_COUNT=4
};
class HashGroup {
    Hash h[HASH_COUNT];
public:
    HashGroup(char s) : h{ Hash(29, s), Hash(97, s), Hash(7919, s), Hash(7, s) } {}
public:
    void push_back(char c) {
        for(int i=0;i<HASH_COUNT;++i) h[i].push_back(c);
    }

    void push_front(char c) {
        for(int i=0;i<HASH_COUNT;++i) h[i].push_front(c);
    }

    void update_front_push_back(char old, char c) {
        for(int i=0;i<HASH_COUNT;++i) h[i].update_front_push_back(old, c);
    }


    bool equals(const HashGroup& o) {
        for(int i=0;i<HASH_COUNT;++i) {
            if(h[i].code()!=o.h[i].code()) return false;
        }
        return true;
    }

};

/**
 * Kolejnka cykliczna znaków, która kompresuje znaki do 5 bitów.
 */
class CharQueue {
public:
    // Maksymalny rozmiar kolejki - mamy tylko niecałe 2 MB (4 MB - kod binarny - stos)
    static const int SIZE=3184000; // => (3184000*5+7)/8 = 1 990 000 b

    /** Rozmiar w bajtach dla pomieszcenia danej ilości znaków */
    static const int BYTE_SIZE=(SIZE*5+7)/8;
private:
    int fix;
    /** Rozmiar danych; położenie końcówki */
    int size;
    unsigned char* data;
public:
    CharQueue() : fix(0), size(0), data(new unsigned char[BYTE_SIZE+1]) {
    }
    ~CharQueue() {
        delete[] data;
    }
public:
    void put(unsigned char c) {
        /** Położenie w bitach */
        const int bitPos=(size*5);
        int bytePos=(bitPos>>3) - fix;  // bajt w tablicy
        const int shift=bitPos&7;   // przesunięcie w bajcie
        if(bytePos>=BYTE_SIZE) {
            bytePos-=BYTE_SIZE; fix+=BYTE_SIZE;
        }
        unsigned short* d=(unsigned short*)(data+bytePos);
        const unsigned short mask=~((unsigned short)0x1f<<shift);

        *d=(*d & mask) | ((c-'a')<<shift);
        ++size;
    }

    inline unsigned char operator[](int at) {
        const int bitPos=(at*5);
        int bytePos=(bitPos>>3) - fix;  // bajt w tablicy
        const int shift=bitPos&7;   // przesunięcie w bajcie
        if(bytePos<0) bytePos+=BYTE_SIZE;

        unsigned short d=*((unsigned short*)(data+bytePos));
        const unsigned char in=(unsigned char)( (d>>shift)&0x1f );
        return (unsigned char)(in+'a');
    }
};

const int MAX_SIZE=20000000;
const int HALF_SIZE=MAX_SIZE/2;

const int MAX_UNKNOW=CharQueue::SIZE*2-1;

class HashCalc {
    HashGroup a,b;
    CharQueue q;
    int size;
public:
    HashCalc(char la, char lb) : a(la-'a'), b(lb-'a'), size(2) {
        q.put(la);
        q.put(lb);
    }
public:
    inline void process(char c) {
        // tylko do połowy wrzucamy do bufora,
        // bo dostęp wstecz potrzebny jest tylko do size/2;
        if(size<=HALF_SIZE) q.put(c);

        const char half=q[size/2];
        if((size&1)==0) {
            a.push_front(half-'a');
            b.push_back(c-'a');
        } else {
            b.update_front_push_back(half-'a', c-'a');
        }
        ++size;
    }

    inline int getSize() const { return size; }

    bool hashCheck() {
        return a.equals(b);
    }

    bool simpleCheck() {
        const int half=(size+1)/2;
        for(int i=0;i<half;++i) {
            if(q[i]!=q[size-i-1]) return false;
        }
        return true;
    }

    bool check() {
        if(size<CharQueue::SIZE) return simpleCheck();
        else return hashCheck();
//        return hashCheck();
    }

};

bool smallCheck(istream& in, int n) {
    // czytamy całość i sprawdzamy
    CharQueue q;
    for(;;) {
        in.get(buf, READ_BUF+1);
        int i;
        for(i=0;buf[i]!='\0';++i) {
            q.put((uint8_t )buf[i]);
        }
        if(i<READ_BUF) break;
    }

    const int half=(n+1)/2;
    for(int i=0;i<half;++i) {
        if(q[i]!=q[n-i-1]) return false;
    }
    return true;
}

bool bigCheck(istream& in, int n) {
    const int half=(n+1)/2;
    int read=1;
    in.get(buf, 2);

    HashGroup h1(buf[0]);
    for(;;) {
        const int limit=min(READ_BUF, half-read);
        if(limit==0) break;
        in.get(buf, limit+1);
        int i;
        for(i=0;buf[i]!='\0';++i) h1.push_back(buf[i]);
        read+=i;
    }
    if(n&1) in.unget();    // środek jest w dwóch wyrazach

    in.get(buf, 2);
    read=1;
    HashGroup h2(buf[0]);
    for(;;) {
        const int limit=min(READ_BUF, half-read);
        if(limit==0) break;
        in.get(buf, limit+1);
        int i;
        for(i=0;buf[i]!='\0';++i) h2.push_front(buf[i]);
        read+=i;
    }

    return h1.equals(h2);
}

bool unknownCheck(istream& in) {
    in.get(buf, 3);    // dwa startowe znaki (3 = na null
    if(buf[0]=='\0' || buf[1]=='\0') {  // jeżeli nie ma drugiego znaku, to jest to palindrom jednoznakowy
        return true;
    } else {
        HashCalc calc(buf[0], buf[1]);
        for(;;) {
            in.get(buf, READ_BUF+1);
            int i;
            for(i=0;buf[i]!='\0' && buf[i]!='\n' && buf[i]!='\r';++i) {
                calc.process(buf[i]);
                if(calc.getSize()>=MAX_UNKNOW) {    // powyżej tego będą błędy
                    return false;
                }
            }
            if(i<READ_BUF) {
                break;
            }
        }
        return calc.check();
    }
}

bool process(int n, istream& in) {
    if(n>0) {   // znana długość danych
        if(n<CharQueue::SIZE) { // mała długość - po znaku
            return smallCheck(in, n);
        } else {    // duża długość - hashe
            return bigCheck(in, n);
        }
    } else {    // nieznana dłuość - po  hashu
        return unknownCheck(in);
    }
}


int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin>>n;

    // kończymy linię
    while(isspace(cin.get()));
    cin.unget();

    bool res=process(n, cin);
   cout<<(res?"TAK":"NIE")<<endl;

    return 0;
}