#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")

// hloya template v26

// ░░░░░░░▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄░░░░░░
// ░░░░░░█░░▄▀▀▀▀▀▀▀▀▀▀▀▀▀▄░░█░░░░░
// ░░░░░░█░█░▀░░░░░▀░░▀░░░░█░█░░░░░
// ░░░░░░█░█░░░░░░░░▄▀▀▄░▀░█░█▄▀▀▄░
// █▀▀█▄░█░█░░▀░░░░░█░░░▀▄▄█▄▀░░░█░
// ▀▄▄░▀██░█▄░▀░░░▄▄▀░░░░░░░░░░░░▀▄
// ░░▀█▄▄█░█░░░░▄░░█░░░▄█░░░▄░▄█░░█
// ░░░░░▀█░▀▄▀░░░░░█░██░▄░░▄░░▄░███
// ░░░░░▄█▄░░▀▀▀▀▀▀▀▀▄░░▀▀▀▀▀▀▀░▄▀░
// ░░░░█░░▄█▀█▀▀█▀▀▀▀▀▀█▀▀█▀█▀▀█░░░
// ░░░░▀▀▀▀░░▀▀▀░░░░░░░░▀▀▀░░▀▀░░░░

#include <bits/stdc++.h>
using namespace std;

bool dbg = 0;

clock_t start_time = clock();
#define current_time                                                           \
  fixed << setprecision(6) << (ld)(clock() - start_time) / CLOCKS_PER_SEC

#define f first
#define s second
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define eb emplace_back
#define all(v) (v).begin(), (v).end()
#define sz(v) ((int)(v).size())
#define sqr(x) ((x) * (x))

#define ull unsigned long long
#define ll long long
#define ld long double
#define pii pair<int, int>
#define umap unordered_map<int, int>

#define files1 freopen("input.txt", "r", stdin)
#define files2 freopen("output.txt", "w", stdout)
#define files                                                                  \
  files1;                                                                      \
  files2
#define fast_io                                                                \
  ios_base::sync_with_stdio(0);                                                \
  cin.tie(0)

// #define endl '\n'
#define ln(i, n) " \n"[(i) == (n)-1]

void bad(string mes = "NO") {
  cout << mes;
  exit(0);
}
void bad(int mes) {
  cout << mes;
  exit(0);
}

template <typename T> string bin(T x, int st = 2) {
  string ans = "";
  while (x > 0) {
    ans += char('0' + x % st);
    x /= st;
  }
  reverse(ans.begin(), ans.end());
  return ans.empty() ? "0" : ans;
}

mt19937_64 mt_rand(228 // chrono::system_clock::now().time_since_epoch().count()
);

template <typename T1, typename T2> inline bool upmax(T1 &a, T2 b) {
  return (a < b ? (a = b, true) : false);
}
template <typename T1, typename T2> inline bool upmin(T1 &a, T2 b) {
  return (b < a ? (a = b, true) : false);
}

// inline int popcount(int x){
//     int count = 0;
//     __asm__ volatile("POPCNT %1, %0;":"=r"(count):"r"(x):);
//     return count;
// }

template <typename T> T input() {
  T ans = 0, m = 1;
  char c = ' ';

  while (!((c >= '0' && c <= '9') || c == '-')) {
    c = getchar();
  }

  if (c == '-')
    m = -1, c = getchar();
  while (c >= '0' && c <= '9') {
    ans = ans * 10 + (c - '0'), c = getchar();
  }
  return ans * m;
}

template <typename T> T gcd(T a, T b) {
  while (b) {
    a %= b;
    swap(a, b);
  }
  return a;
}

template <typename T> void read(T &a) { a = input<T>(); }
template <typename T> void read(T &a, T &b) { read(a), read(b); }
template <typename T> void read(T &a, T &b, T &c) { read(a, b), read(c); }
template <typename T> void read(T &a, T &b, T &c, T &d) {
  read(a, b), read(c, d);
}

const int inf = 1e9 + 20;
const short short_inf = 3e4 + 20;
const long double eps = 1e-12;
const int maxn = (int)1500 + 3, base = 998244353;
const ll llinf = 2e18 + 5;
const int mod = 1e9 + 7;

bool solveBrute(vector<int> a) {
  int reqsteps = accumulate(all(a), 0);
  function<bool(vector<int>, int, int)> rec = [&](vector<int> b, int i,
                                                  int steps) -> bool {
    b[i] -= 1;
    if (b[i] < 0) {
      return false;
    }
    if (steps == reqsteps) {
      return true;
    }
    bool res = 0;
    if (i != b.size() - 1) {
      res |= rec(b, i + 1, steps + 1);
    }
    if (i != 0) {
      res |= rec(b, i - 1, steps + 1);
    }
    return res;
  };

  for (int i = 0; i < a.size(); ++i) {
    if (rec(a, i, 1)) {
      // cout << "start " << i << endl;
      return 1;
    }
  }
  return 0;
}

//  l0 l1 l2 l3 l4  l5
// x  x  x  x  x  x
//  r0 r1 r2 r3 r4  r5
// indegi = l[i] + r[i - 1]
// outdgi = l[i-1] + r[i]

// all equal OR
// only one where indegi=outdgi+1 and one where indegi=outdgi-1
//

// l[i] + r[i] > 0

// l[i] - l[i-1] = r[i] - r[i-1]
// fix delta D
// max one place where D+1 and max one place where D-1

bool solveMoreOpt2(vector<int> b) {
  vector<int> a;
  for (int i = 0; i < b.size(); ++i) {
    if (b[i] != 0) {
      for (int j = b.size() - 1; j >= i; --j) {
        if (b[j] != 0) {
          a = vector<int>(b.begin() + i, b.begin() + j + 1);
          break;
        }
      }
      break;
    }
  }
  b = a;

  int n = b.size();
  if (n == 1) {
    return b[0] == 1;
  }

  vector<int> l(n), r(n);

  // like assumes that 0 is not s or e?
  for (int i = 0; i < n; ++i) {
    l[i] = b[i] - (i == 0 ? 0 : l[i - 1]);
  }
  r = l;

  // Select one s an e:
  // s: l[i]-- r[i+1]++ l[i+2]-- r[i+3]++...
  // e: r[i]-- l[i+1]++ r[i+2]-- l[i+3]++...
  // l[i] + r[i] > 0
  // l[n-1] == 0 and r[n-1] == 0

  // s: l[i]-- r[i+1]++ l[i+2]-- r[i+3]++...
  // e:                   r[i]-- l[i+1]++ r[i+2]-- l[i+3]++...

  // pars=pare
  // -2 +2 -2 +2
  // pars!=pare
  // -1 1 -1 0 0 0 0

  // 2 28 0 28 6 22

  // pars=pare
  // -1 1 -1 1 -2 2 -2 2

  auto z = [&](int x) { return x == 0 ? 1 : 0; };

  auto z2 = [&](int x) { return x == 0 ? -1 : 1; };

  // cout << "T" <<endl;
  // for (int i = 0; i < n; ++i) {
  //   cout << l[i] << endl;
  // }

  for (int pars = 0; pars < 2; ++pars) {
    for (int pare = 0; pare < 2; ++pare) {
      bool ok = true;
      int parlast = (n - 1) % 2;
      int llast = l[n - 1] - z(pars ^ parlast) + z(pare ^ parlast ^ 1);
      int rlast = r[n - 1] - z(pare ^ parlast) + z(pars ^ parlast ^ 1);

      if (llast == 0 && rlast == 0) {
        if (2 * l[0] <= 0) {
          ok = false;
        }
        if (ok) {
          int s = n + 5, e = n + 5;
          auto delta = [&](int i, int s, int e) {
            int pari = i % 2;
            int deltas = - z(pars ^ pari) + z(pars ^ pari ^ 1);
            int deltae = - z(pare ^ pari) + z(pare ^ pari ^ 1);
            int res = 0;
            if (i >= s) {
              res += deltas;
            }
            if (i >= e) {
              res += deltae;
            }
            return res;
          };
          auto enablesomething = [&](int i) {
            int pari = i % 2;
            if (pari == pare && e == n + 5) {
              e = i;
              return;
            }
            if (pari == pars && s == n + 5) {
              s = i;
              return;
            }
          };
          for (int i = 0; i + 1 < n - 1; ++i) {
            int sum = 2 * l[i + 1];
            int d = delta(i + 1, s, e);
            if (sum + d <= 0) {
              enablesomething(i);
            }
            d = delta(i + 1, s, e);
            if (sum + d <= 0) {
              enablesomething(i);
            }
          }
          for (int i = 0; i + 1 < n; ++i) {
            int sum = 2 * l[i];
            int d = delta(i, s, e);
            if (sum + d <= 0) {
              ok = false;
            }
          }
        }
        if (ok) {
          // cout << "OK " << pars << ' ' << pare << endl;
          // for (int i = 0; i + 1 < n; ++i) {
          //   int sum = 2 * l[i];
          //   cout << sum << endl;
          // }
          return 1;
        }
      }
    }
  }

  // auto applys = [&](int s, int d) {
  //   for (int i = s; i < n; i += 2) {
  //     l[i] -= d;
  //     if (i + 1 < n) {
  //       r[i + 1] += d;
  //     }
  //   }
  // };

  // auto applye = [&](int e, int d) {
  //   for (int i = e; i < n; i += 2) {
  //     r[i] -= d;
  //     if (i + 1 < n) {
  //       l[i + 1] += d;
  //     }
  //   }
  // };

  // for (int s = 0; s < n; ++s) {
  //   for (int e = 0; e < n; ++e) {
  //     applys(s, 1);
  //     applye(e, 1);

  //     bool ok = true;
  //     for (int i = 0; i + 1 < n; ++i) {
  //       if (l[i] + r[i] <= 0) {
  //         ok = false;
  //         break;
  //       }
  //     }
  //     if (l[n - 1] == 0 && r[n - 1] == 0 && ok) {

  //       for (int i = 0; i + 1 < n; ++i) {
  //         assert(l[i] >= 0 && r[i] >= 0);
  //       }

  //       return 1;
  //     }

  //     applys(s, -1);
  //     applye(e, -1);
  //   }
  // }

  return 0;
}

// // каждый раз меняется четность
// bool solveMoreOpt(vector<int> b) {
//   // есть граф, вершины l и вершины r
//   // l[f] = 0
//   // r[t] = 0
//   // есть ребра которые показывают сумму
//   // l[i] + r[i] == b[i] - (i == e)
//   // r[i-1] + l[i + 1] == b[i] - (i == s)

//   // проверка на связность
//   // l[i + 1] + r[i] > 0

//   for (int s = 0; s < b.size(); ++s) {
//     for (int e = 0; e < b.size(); ++e) {
//       int f = 0;            // todo skip 0
//       int t = b.size() - 1; // todo skip 0

//       while (b[f] == 0) {
//         f++;
//       }
//       while (b[t] == 0) {
//         t--;
//       }

//       vector<int> l(b.size());
//       vector<int> r(b.size());

//       // r[f] = b[f] - (f == e);
//       l[f] = 0;

//       // l[i] + r[i] == b[i] - (i == e)
//       // r[i-1] + l[i + 1] == b[i] - (i == s)
//       // l[1] == 0
//       // r[n] = 0
//       // l[i + 1] + r[i] > 0

//       bool ok = true;
//       for (int i = f; i <= t; ++i) {
//         r[i] = b[i] - (i == e) - l[i];
//         if (i + 1 <= t) {
//           l[i + 1] = b[i] - (i == s) - (i == f ? 0 : r[i - 1]);
//         }
//         if (l[i] < 0 || r[i] < 0) {
//           ok = false;
//           break;
//         }
//       }
//       // disjoint components
//       for (int i = f; i + 1 <= t; ++i) {
//         if (r[i] + l[i + 1] <= 0) {
//           ok = false;
//           break;
//         }
//       }
//       if (r[t] == 0 && ok) {
//         return 1;
//       }
//     }
//   }
//   return 0;
// }

int main() {
  // files1;
  fast_io;

  int t;
  cin >> t;

  while (t--) {
    int n;
    cin >> n;
    vector<int> a(n);
    for (auto &x : a) {
      cin >> x;
    }
    cout << (solveMoreOpt2(a) ? "TAK" : "NIE") << '\n';
  }

  // int tests = 10000000;
  // for (int test = 1000;; ++test) {
  //   srand(test);

  //   int n = rand() % 5 + 1; // N==1 different simple if
  //   vector<int> a(n);
  //   for (auto &x : a) {
  //     x = rand() % 100 + 0;
  //   }
  //   int sum = accumulate(all(a), 0);
  //   if (sum == 0) {
  //     a[0] = 1;
  //   }

  //   bool ans1 = solveMoreOpt(a);
  //   bool ans2 = solveMoreOpt2(a);

  //   if (ans1 != ans2) {
  //     cout << "test: " << test << endl;
  //     cout << "brute " << ans1 << endl;
  //     cout << "moreopt " << ans2 << endl;
  //     for (auto x : a) {
  //       cout << x << ' ';
  //     }
  //     cout << endl;
  //     exit(228);
  //   }
  //   if (test % 100 == 0) {
  //     cout << "Tests passed: " << test << endl;
  //   }
  // }

  return 0;
}