#include <cstdint>
#include <cstdio>
#include <memory>
#include <vector>
#include <deque>

using namespace std;


// two-way hasher
struct Hasher2w {
  virtual void append(char ch) = 0;
  virtual void prepend(char ch) = 0;
  virtual bool operator==(Hasher2w const &rhs) const = 0;
  bool operator!=(Hasher2w const &rhs) { return not (*this == rhs); }
  
  virtual shared_ptr<Hasher2w> clone() const = 0;
};


// counts occurrences
struct ByteHistogram: Hasher2w {
  vector<size_t> counter;
  
  ByteHistogram(): counter(256, 0) { }
  
  void append(char ch) {
    counter[(unsigned char)(ch)]++;
  }
  
  void prepend(char ch) {
    counter[(unsigned char)(ch)]++;
  }
  
  bool operator==(Hasher2w const &rhs) const {
    ByteHistogram const *rhstp = dynamic_cast<ByteHistogram const *>(&rhs);
    if(rhstp == nullptr) return false;
    return counter == rhstp->counter;
  }
  
  bool possiblePalindrome() const {
    size_t odds = 0;
    for(size_t i = 0; i < 256; i++) {
      if(counter[i] % 2 == 1) odds++;
      if(odds >= 2) return false;
    }
    return true;
  }
  
  virtual shared_ptr<Hasher2w> clone() const { return make_shared<ByteHistogram>(*this); }
};


// keeps prefix and suffix
struct SideKeeper: Hasher2w {
  size_t const length;
  deque<char> prefix;
  deque<char> suffix;
  
  SideKeeper(size_t _length): length(_length) { }
  
  void append(char ch) {
    suffix.push_back(ch);
    if(suffix.size() > length) suffix.pop_front();
    if(prefix.size() < length) prefix.push_back(ch);
  }
  
  void prepend(char ch) {
    prefix.push_front(ch);
    if(prefix.size() > length) prefix.pop_back();
    if(suffix.size() < length) suffix.push_front(ch);
  }
  
  bool operator==(Hasher2w const &rhs) const {
    SideKeeper const *rhstp = dynamic_cast<SideKeeper const *>(&rhs);
    if(rhstp == nullptr) return false;
    return prefix == rhstp->prefix and suffix == rhstp->suffix;
  }
  
  virtual shared_ptr<Hasher2w> clone() const { return make_shared<SideKeeper>(*this); }
};


// calculates radix-based multiple-digit number modulo dividend (you append/prepend the digits)
struct DigitalHasher2w: Hasher2w {
  uint32_t const dividend;
  uint32_t const radix;
  unsigned int degree;
  uint32_t powval;
  uint32_t state;
  
  DigitalHasher2w(uint32_t _dividend, uint32_t _radix): dividend(_dividend), radix(_radix), degree(0), powval(1), state(0) { }
  
  void append(char ch) {
    state = ((unsigned char)(ch) * uint64_t(powval) + state) % dividend;
    powval = (powval * uint64_t(radix)) % dividend;
    degree++;
  }
  
  void prepend(char ch) {
    state = (state * uint64_t(radix) + (unsigned char)(ch)) % dividend;
    powval = (powval * uint64_t(radix)) % dividend;
    degree++;
  }
  
  bool operator==(Hasher2w const &rhs) const {
    DigitalHasher2w const *rhstp = dynamic_cast<DigitalHasher2w const *>(&rhs);
    if(rhstp == nullptr) return false;
    return state == rhstp->state;
  }
  
  virtual shared_ptr<Hasher2w> clone() const { return make_shared<DigitalHasher2w>(*this); }
};


// calculates (1*a0 + 2*a1 + 3*a2 + ...) MOD dividend (you append/prepend elements of (a) sequence)
// keeps the value of (a0 + a1 + ...) MOD dividend and uses it in comparisons as well
struct LinearHasher2w: Hasher2w {
  uint32_t const dividend;
  uint32_t sum;
  uint32_t count;
  uint32_t state;
  
  LinearHasher2w(uint32_t _dividend): dividend(_dividend), sum(0), count(0), state(0) { }
  
  void append(char ch) {
    unsigned char t = ch;
    count++;
    state = (state + t * uint64_t(count)) % dividend;
    sum = (sum + uint64_t(t)) % dividend;
  }
  
  void prepend(char ch) {
    unsigned char t = ch;
    count++;
    state = (state + uint64_t(sum) + t) % dividend;
    sum = (sum + uint64_t(t)) % dividend;
  }
  
  bool operator==(Hasher2w const &rhs) const {
    LinearHasher2w const *rhstp = dynamic_cast<LinearHasher2w const *>(&rhs);
    if(rhstp == nullptr) return false;
    return state == rhstp->state and sum == rhstp->sum;
  }
  
  virtual shared_ptr<Hasher2w> clone() const { return make_shared<LinearHasher2w>(*this); }
};


// use multiple two-way hashers as one
struct MultiHasher2w: Hasher2w {
  vector< shared_ptr<Hasher2w> > hashers;
  
  MultiHasher2w(vector< shared_ptr<Hasher2w> > &_hashers): hashers(_hashers) { }
  
  MultiHasher2w(MultiHasher2w const &arg) {
    for(auto const &ptr: arg.hashers) {
      hashers.push_back(ptr->clone());
    }
  }
  
  void append(char ch) {
    for(size_t i = 0; i < hashers.size(); i++) hashers[i]->append(ch);
  }
  
  void prepend(char ch) {
    for(size_t i = 0; i < hashers.size(); i++) hashers[i]->prepend(ch);
  }
  
  bool operator==(Hasher2w const &rhs) const {
    MultiHasher2w const *rhstp = dynamic_cast<MultiHasher2w const *>(&rhs);
    if(rhstp == nullptr) return false;
    if(hashers.size() != rhstp->hashers.size()) return false;
    for(size_t i = 0; i < hashers.size(); i++) if(*(hashers[i]) != *(rhstp->hashers[i])) return false;
    return true;
  }
  
  virtual shared_ptr<Hasher2w> clone() const { return make_shared<MultiHasher2w>(*this); }
};


// wrapper for ignoring all the characters besides small latin letters
struct FilteredLLHasher2wWrapper: Hasher2w {
  shared_ptr<Hasher2w> ptr;
  FilteredLLHasher2wWrapper(Hasher2w &_hasher): ptr(&_hasher) { }
  FilteredLLHasher2wWrapper(shared_ptr<Hasher2w> const &_ptr): ptr(_ptr) { }
  
  FilteredLLHasher2wWrapper(FilteredLLHasher2wWrapper const &arg): ptr(arg.ptr->clone()) { }
  
  void append(char ch) {
    if(not ('a' <= ch and ch <= 'z')) return;
    ptr->append(ch);
  }
  
  void prepend(char ch) {
    if(not ('a' <= ch and ch <= 'z')) return;
    ptr->prepend(ch);
  }
  
  bool operator==(Hasher2w const &rhs) const {
    FilteredLLHasher2wWrapper const *rhstp = dynamic_cast<FilteredLLHasher2wWrapper const *>(&rhs);
    if(rhstp != nullptr) return *ptr == *(rhstp->ptr);
    return *ptr == rhs;
  }
  
  virtual shared_ptr<Hasher2w> clone() const { return make_shared<FilteredLLHasher2wWrapper>(*this); }
};


int main() {
  vector< shared_ptr<Hasher2w> > hashers;
  
  shared_ptr<ByteHistogram> hist = make_shared<ByteHistogram>();
  
  hashers.push_back(hist);
  hashers.push_back(make_shared<SideKeeper>(4096));
  hashers.push_back(make_shared<DigitalHasher2w>(1662389207, 1200099553));
  hashers.push_back(make_shared<DigitalHasher2w>(1630171901, 1214103271));
  hashers.push_back(make_shared<DigitalHasher2w>(1822084421, 1338144299));
  hashers.push_back(make_shared<DigitalHasher2w>(1107565939, 1030805731));
  hashers.push_back(make_shared<LinearHasher2w>(1755431533));
  hashers.push_back(make_shared<LinearHasher2w>(1631560141));
  hashers.push_back(make_shared<LinearHasher2w>(1759200251));
  hashers.push_back(make_shared<LinearHasher2w>(1941468271));
  
  FilteredLLHasher2wWrapper fh(make_shared<MultiHasher2w>(hashers));
  FilteredLLHasher2wWrapper rh(fh);
  
  for(int ch; (ch = getchar_unlocked()) != EOF;) {
    fh.append(ch);
    rh.prepend(ch);
  }
  
  if(hist->possiblePalindrome() and fh == rh) {
    puts("TAK");
  } else {
    puts("NIE");
  }
  
  return 0;
}