#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


namespace enu_tree {
constexpr int MAX_N = 21;

using Id = pair<int, int>;

// (largest subtree, remaining tree)
vector<pair<Id, Id>> T[MAX_N + 1];

inline int TLen(int n) {
  return T[n].size();
}

// tie-break (n/2) + (n/2)
inline bool isCentroid(int n, int x) {
  return (T[n][x].first <= T[n][x].second);
}

// |non-root subtree| <= limDn
void build(int limDn = MAX_N - 1) {
  for (int n = 0; n <= MAX_N; ++n) T[n].clear();
  T[1].emplace_back(Id(0, 0), Id(0, 0));
  for (int dn = 1; dn < MAX_N && dn <= limDn; ++dn) for (int dx = 0; dx < TLen(dn); ++dx) {
    for (int n = 1; n + dn <= MAX_N; ++n) for (int x = 0; x < TLen(n); ++x) {
      T[n + dn].emplace_back(Id(dn, dx), Id(n, x));
    }
  }
}

void getParDfs(int n, int x, int p, int &id, vector<int> &par) {
  const int u = id++;
  par[u] = p;
  for (int nn = n, xx = x; nn > 1; ) {
    const auto &t = T[nn][xx];
    getParDfs(t.first.first, t.first.second, u, id, par);
    nn = t.second.first;
    xx = t.second.second;
  }
}
vector<int> getPar(int n, int x) {
  assert(1 <= n); assert(n <= MAX_N);
  assert(0 <= x); assert(x < TLen(n));
  int id = 0;
  vector<int> par(n, -1);
  getParDfs(n, x, -1, id, par);
  return par;
}
vector<int> getPar(const Id &id) {
  return getPar(id.first, id.second);
}
}  // enu_tree

////////////////////////////////////////////////////////////////////////////////


namespace solver {
int N;
char S[100'010];
char T[100'010];
vector<int> A, B;

bool run() {
  bool hasS[2] = {}, hasT[2] = {};
  for (int u = 0; u < N; ++u) hasS[S[u] - '0'] = true;
  for (int u = 0; u < N; ++u) hasT[T[u] - '0'] = true;
  for (int c = 0; c < 2; ++c) {
    if (!hasS[c] && hasT[c]) {
      return false;
    }
  }
  int cntS = 0, cntT = 0;
  for (int i = 0; i < N - 1; ++i) {
    if (S[A[i]] != S[B[i]]) ++cntS;
    if (T[A[i]] != T[B[i]]) ++cntT;
  }
  if (cntT == N - 1 && strcmp(S, T)) {
    return false;
  }
  vector<int> deg(N, 0);
  for (int i = 0; i < N - 1; ++i) {
    ++deg[A[i]];
    ++deg[B[i]];
  }
  if (*max_element(deg.begin(), deg.end()) <= 2) {
    if (cntS < cntT) {
      return false;
    } else if (cntS == cntT) {
      for (int u = 0; u < N; ++u) if (deg[u] <= 1) {
        if (S[u] != T[u]) {
          return false;
        }
      }
    }
  }
  return true;
}
}  // solver

void exper() {
  using namespace enu_tree;
  build(MAX_N / 2);
  for (int n = 1; n <= 10; ++n) {
    for (int x = 0; x < TLen(n); ++x) if (isCentroid(n, x)) {
      const auto par = getPar(n, x);
      
      /*
      vector<int> deg(n, 0);
      for (int u = 1; u < n; ++u) {
        ++deg[par[u]];
        ++deg[u];
      }
      if (*max_element(deg.begin(), deg.end()) <= 2) {
        continue;
      }
      */
      
      for (int s = 0; s < 1 << n; ++s) {
        queue<int> que;
        vector<int> vis(1 << n, 0);
        vis[s] = 1;
        que.push(s);
        for (; que.size(); ) {
          const int y = que.front();
          que.pop();
          for (int v = 1; v < n; ++v) {
            const int u = par[v];
            if ((y >> u & 1) ^ (y >> v & 1)) {
              for (const int z : {y ^ 1 << u, y ^ 1 << v}) {
                if (!vis[z]) {
                  vis[z] = 1;
                  que.push(z);
                }
              }
            }
          }
        }
        
        for (int t = 0; t < 1 << n; ++t) {
          solver::N = n;
          for (int u = 0; u < n; ++u) {
            solver::S[u] = '0' + (s >> u & 1);
            solver::T[u] = '0' + (t >> u & 1);
          }
          solver::A.resize(n - 1);
          solver::B.resize(n - 1);
          for (int u = 1; u < n; ++u) {
            solver::A[u - 1] = par[u];
            solver::B[u - 1] = u;
          }
          const bool brt = vis[t];
          const bool slv = solver::run();
          if (brt != slv) {
            cerr << "FAIL " << n << " " << par << " " << solver::S << " " << solver::T << ": " << brt << " " << slv << endl;
          }
          assert(brt == slv);
        }
        
        // if (s == 0 || s == (1 << n) - 1) continue;
        /*
        for (int t = 0; t < 1 << n; ++t) if (!vis[t]) {
          if (t == 0 || t == (1 << n) - 1) continue;
          
          bool bip = true;
          for (int u = 1; u < n; ++u) {
            bip = bip && ((t >> par[u] & 1) != (t >> u & 1));
          }
          if (bip) continue;
          
          cerr << n << " " << x << " " << par << ": ";
          for (int u = 0; u < n; ++u) cerr << (s >> u & 1);
          cerr << " ";
          for (int u = 0; u < n; ++u) cerr << (t >> u & 1);
          cerr << endl;
        }
        */
      }
    }
    cerr << "DONE n = " << n << endl;
  }
}


int main() {
  // exper();
  
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    using namespace solver;
    scanf("%d", &N);
    scanf("%s", S);
    scanf("%s", T);
    A.resize(N - 1);
    B.resize(N - 1);
    for (int i = 0; i < N - 1; ++i) {
      scanf("%d%d", &A[i], &B[i]);
      --A[i];
      --B[i];
    }
    
    const bool ans = run();
    puts(ans ? "TAK" : "NIE");
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}