#include <iostream>

using namespace std;
template <typename Tip>
class Iterator;
template <typename Tip>
class Lista
{
    struct Cvor
    {
        Tip element;
        Cvor *sljedeci;

    };
    Cvor *prvi, *zadnji, *trenutni;
public:
    Lista ()
    {
        prvi=0;
        zadnji=0;
        trenutni=0;
    }
    ~Lista()
    {
        Cvor *p = prvi;
        Cvor *s;
        while (p!=zadnji)
        {
            s=p;
            p=p->sljedeci;
            delete s;
        }
        prvi=0;
        zadnji=0;
    }
    Lista(const Lista &x)
    {
        prvi=new Cvor;
        prvi->element=x.prvi->element;
        Cvor *p=prvi;
        Cvor *p1=x.prvi;
        p1=p1->slijedeci;
        while (1)
        {
            p->slijedeci=new Cvor;
            p=p->slijedeci;
            p->element=p1->element;
            if (p1==x.trenutni) trenutni=p;
            if (p1->slijedeci==0)
            {
                p->slijedeci=0;
                break;
            }
            p1=p1->slijedeci;
        }
        zadnji=p;
    }
    Lista &operator =(const Lista &x)
    {
        Cvor *m = prvi;
        Cvor *s;
        while (m!=zadnji)
        {
            s=m;
            m=m->sljedeci;
            delete s;
        }
        prvi=new Cvor;
        prvi->element=x.prvi->element;
        Cvor *p=prvi;
        Cvor *p1=x.prvi;
        p1=p1->slijedeci;
        while (1)
        {
            p->slijedeci=new Cvor;
            p=p->slijedeci;
            p->element=p1->element;
            if (p1==x.trenutni) trenutni=p;
            if (p1->slijedeci==0)
            {
                p->slijedeci=0;
                break;
            }
            p1=p1->slijedeci;
        }
        zadnji=p;
        return *this;
    }
    void brisi()
    {
        Cvor *p = prvi;
        Cvor *s;
        while (p!=zadnji)
        {
            s=p;
            p=p->sljedeci;
            delete s;
        }
        prvi=0;
        zadnji=0;
    }

    int brojElemenata()
    {
        int br=0;
        for (Cvor *p = prvi; p != 0; p = p->sljedeci)
            br++;
        return br;
    }
    Tip Trenutni()
    {
        if (brojElemenata()==0) throw "Lista je prazna";
        else return trenutni->element;
    }
    bool prethodni()
    {
        if (trenutni==prvi) return false;
        else
        {
            Cvor *p=prvi;
            while (p->sljedeci!=trenutni)
            {
                p=p->sljedeci;
            }
            trenutni=p;
            return true;
        }
    }
    bool sljedeci()
    {
        if (trenutni==zadnji) return false;
        else
        {
            trenutni=trenutni->sljedeci;
            return true;
        }
    }
    Tip operator [] (int i) const
    {
        if (i<0 || i>brojElemenata()) throw "neispravan indeks";
        else
        {
            Cvor *p=prvi;
            int br=0;
            while (br!=i)
            {
                p=p->sljedeci;
                br++;
            }
            return p->element;
        }
    }
    void dodajIspred (const Tip &x)
    {
        Cvor *novi=new Cvor;
        novi->element=x;
        novi->sljedeci=0;
        if (brojElemenata()==0)
        {
            prvi=novi;
            zadnji=novi;
            trenutni=novi;
        }
        else if (trenutni==prvi)
        {
            novi->sljedeci=prvi;
            prvi=novi;
        }

        else
        {
            Cvor *prethodni=prvi;
            novi->sljedeci=trenutni;
            while (prethodni->sljedeci != trenutni)
                prethodni=prethodni->sljedeci;
            prethodni->sljedeci=novi;
        }
    }
    void dodajIza (const Tip &x)
    {
        Cvor *novi=new Cvor;
        novi->element=x;
        novi->sljedeci=0;
        if (brojElemenata()==0)
        {
            prvi=novi;
            zadnji=novi;
            trenutni=novi;
        }
        else if (trenutni==zadnji)
        {
            trenutni->sljedeci=novi;
            zadnji=novi;
        }
        else
        {
            novi->sljedeci=trenutni->sljedeci;
            trenutni->sljedeci=novi;
        }
    }
    void obrisi()
    {
        if (brojElemenata()==0) throw "Niz je prazan";
        else if (trenutni==prvi)
        {
            prvi=prvi->sljedeci;
            delete trenutni;
            trenutni=prvi;
        }
        else
        {
            Cvor *prethodni;
            prethodni=prvi;
            while (prethodni->sljedeci != trenutni)
            {
                prethodni=prethodni->sljedeci;
            }
            prethodni->sljedeci=trenutni->sljedeci;
            delete trenutni;
            trenutni=prethodni;
        }
    }
    void pocetak()
    {
        trenutni = prvi;
    }
    void kraj()
    {

        trenutni = zadnji;
    }

    friend class Iterator<Tip>;
    };




template <typename Tip>
class Stek
{
    struct Cvor
    {
        Tip element;
        Cvor *sljedeci;
        ~Cvor()
        {
            element =0;
            sljedeci=0;
        }
    };
    Cvor *prvi,*zadnji;
public:
    Stek ()
    {
        prvi=0;
        zadnji=0;
    }
    ~Stek()
    {
        Cvor *p = prvi;
        Cvor *s;
        while (p!=zadnji)
        {
            s=p;
            p=p->sljedeci;
            delete s;
        }
    }
    Stek(const Stek& s)
    {
        Cvor *p = s.prvi;
        prvi=0;
        zadnji=0;
        while (p != 0)
        {
            stavi(p->element);
            p = p->sljedeci;
        }

    }
    Stek &operator=(const Stek& s)
    {
        brisi();
        Cvor *p = s.prvi;
        prvi=0;
        zadnji=0;
        while (p != 0)
        {
            stavi(p->element);
            p = p->sljedeci;
        }

    }

    int brojElemenata()
    {
        int br=0;
        for (Cvor *p = prvi; p != 0; p = p->sljedeci)
            br++;
        return br;
    }
    void stavi(const Tip& el)
    {
        Cvor *novi=new Cvor;
        novi->element=el;
        novi->sljedeci=0;
        if (prvi == 0)
        {
            prvi = zadnji = novi;
            zadnji->sljedeci=0;
        }
        else
        {
            zadnji->sljedeci = novi;
            zadnji = novi;
        }

    }
    Tip vrh()
    {
        return (zadnji->element);
    }
    Tip skini()
    {
        Tip x;
        x=zadnji->element;
        if (prvi==zadnji)
        {
            zadnji=0;
            delete prvi;
            prvi=0;
        }
        else
        {
            Cvor *p=prvi;
            while (p->sljedeci!= zadnji)
            {
                p=p->sljedeci;
            }
            delete zadnji;
            p->sljedeci=0;
            zadnji=p;
        }
        return x;
    }
    void brisi()
    {
        Cvor *p = prvi;
        Cvor *s;
        while (p!=zadnji)
        {
            s=p;
            p=p->sljedeci;
            delete s;
        }
        prvi=0;
        zadnji=0;
    }
};


template <typename Tip>
class Red
{
    struct Cvor
    {
        Tip element;
        Cvor *sljedeci;
        ~Cvor()
        {
            element =0;
            sljedeci=0;
        }
    };
    Cvor *prvi,*zadnji;
public:
    Red ()
    {
        prvi=0;
        zadnji=0;
    }
    ~Red()
    {
        Cvor *p = prvi;
        Cvor *s;
        while (p!=zadnji)
        {
            s=p;
            p=p->sljedeci;
            delete s;
        }
    }
    Red (const Red& s)
    {
        Cvor *p = s.prvi;
        prvi=0;
        zadnji=0;
        while (p != 0)
        {
            stavi(p->element);
            p = p->sljedeci;
        }

    }
    Red &operator=(const Red& s)
    {
        brisi();
        Cvor *p = s.prvi;
        prvi=0;
        zadnji=0;
        while (p != 0)
        {
            stavi(p->element);
            p = p->sljedeci;
        }


    }
    int brojElemenata()
    {
        int br=0;
        for (Cvor *p = prvi; p != 0; p = p->sljedeci)
            br++;
        return br;
    }
    void stavi(const Tip& el)
    {
        Cvor *novi=new Cvor;
        novi->element=el;
        novi->sljedeci=0;
        if (prvi == 0)
        {
            prvi = zadnji = novi;
            zadnji->sljedeci=0;
        }
        else
        {
            zadnji->sljedeci = novi;
            zadnji = novi;
        }

    }
    Tip celo()
    {
        return (prvi->element);
    }
    Tip skini()
    {
        Tip x;
        x=prvi->element;
        if (prvi==zadnji)
        {
            zadnji=0;
            delete prvi;
            prvi=0;
        }
        else
        {
            Cvor *p=prvi->sljedeci;
            delete prvi;
            prvi=p;
        }
        return x;
    }
    void brisi()
    {
        Cvor *p = prvi;
        Cvor *s;
        while (p!=zadnji)
        {
            s=p;
            p=p->sljedeci;
            delete s;
        }
        prvi=0;
        zadnji=0;
    }
};


template<typename Tip>
class Iterator
{
    const Lista<Tip> *lista;
    typename Lista<Tip>::Cvor *trenutniLista;
public:
    Iterator (const Lista<Tip> &b) : lista(&b), trenutniLista(b.prvi) {}
    Tip trenutni()
    {

        if (lista!=0)
        {
            if (lista->brojElemenata()==0) throw "Lista je prazna.";
            return trenutniLista->element;
        }

    }
    bool prethodni()
    {

        if (lista!=0)
        {
            if (trenutniLista==lista.prvi) return false;
            else
            {
                typename Lista<Tip>::Cvor *p=lista.prvi;
                while (p->sljedeci!=trenutniLista)
                {
                    p=p->sljedeci;
                }
                trenutniLista=p;
                return true;
            }
        }
    }
    bool sljedeci ()
    {
        if (lista!=0)
        {
            if (trenutniLista==lista.zadnji) return false;
            else
            {
                trenutniLista=trenutniLista->sljedeci;
                return true;
            }
        }
    }
    void pocetak()
    {
        if (lista!=0)
        {
            trenutniLista=lista.prvi;
        }
    }
    void kraj()
    {
        if (lista!=0)
        {
            trenutniLista=lista.zadnji;
        }
    }

};

bool provjeri_zagrade(string tekst)
{
    Stek<char>stek;
    stek.stavi(1);
    int i=0;
    while (tekst[i]!='\0')
    {
        if (tekst[i]=='(' || tekst[i]=='[' ||tekst[i]=='{')
        {
            stek.stavi(tekst[i]);
        }
        if (tekst[i]==')')
        {
            if (stek.vrh()=='(')
                stek.skini();
            else return false;

        }
        if (tekst[i]==']')
        {
            if (stek.vrh()=='[')
                stek.skini();
            else return false;


        }
        if (tekst[i]=='}')
        {
            if (stek.vrh()=='{')
                stek.skini();
            else return false;

        }
        i++;
    }
    return true;
}
template <typename Tip>
int presjek(Stek<Tip> s1, Stek<Tip> s2)
{
    int br=0;
    for (int j=0; j<s2.brojElemenata(); j++)
            if (s2.skini()==s1.vrh())
    {
        s1.skini();
            br++;
        }
        return br;
}
bool palindrom(const Lista<char>& rijec) {
Iterator<char> i1(rijec);
Iterator<char> i2(rijec);
int l=rijec.brojElemenata();
i1.pocetak();
i2.kraj();
int x=0;
bool m=1;
while (x!=l) {
if (i1.sljedeci()!=i2.prethodni()) {
    m=0;
    }
x++; }
return m;
    }



int main()
{
Lista<char> l;
l.dodajIza('R');
l.dodajIza('A');
l.sljedeci();
l.dodajIza('T');
l.sljedeci();
l.dodajIza('A');
l.sljedeci();
l.dodajIza('R');
if (palindrom(l)) cout<<"OK"; else cout<<"NOK";

}