// Patryk Jędrzejczak

#include <bits/stdc++.h>

using namespace std;

#define REP(i, n) for(int i = 0; i < n; ++i)
#define REPR(i, n) for(int i = n - 1; i >= 0; --i)
#define FOR(i, a, b) for(int i = a; i < b; ++i)
#define FORR(i, a, b) for(int i = b - 1; i >= a; --i)
#define EB emplace_back
#define MP make_pair
#define ST first
#define ND second
#define S size
#define RS resize
#define endl '\n'
#define L long long

template<class T> using V = vector<T>;
using PI = pair<int, int>;

void generate_paths(V<V<int>>& g, int v, int p, V<V<int>>& paths) {
  if ((p == -1 || g[p].S() > 2) && g[v].S() < 3) {
    V<int> new_path(1, v);
    paths.EB(new_path);
  }
  else if (g[v].S() < 3) {
    paths.back().EB(v);
  }

  for (int u : g[v]) {
    if (u != p) {
      generate_paths(g, u, v, paths);
    }
  }
}

bool check_path(V<int>& path, V<int>& from, V<int>& to) {
  int from_count = 1;
  int to_count = 1;
  int s = int(path.S());

  FOR(i, 1, s) {
    if (from[path[i]] != from[path[i - 1]]) {
      from_count++;
    }
    if (to[path[i]] != to[path[i - 1]]) {
      to_count++;
    }
  }

  if (from[path[0]] != to[path[0]]) {
    from_count--;
  }
  if (s > 1 && from[path[s - 1]] != to[path[s - 1]]) {
    from_count--;
  }

  return to_count <= from_count;
}

bool check_path2(V<int>& path, V<int>& from, V<int>& to) {
  int from_count = 1;
  int to_count = 1;
  int s = int(path.S());

  FOR(i, 1, s) {
    if (from[i] != from[i - 1]) {
      from_count++;
    }
    if (to[path[i]] != to[path[i - 1]]) {
      to_count++;
    }
  }

  if (from[0] != to[path[0]]) {
    from_count--;
  }
  if (s > 1 && from[s - 1] != to[path[s - 1]]) {
    from_count--;
  }

  return to_count <= from_count;
}

void get_path(V<V<int>>& g, int v, int p, V<int>& path) {
  path.EB(v);
  if (g[v].S() == 2) {
    for (int u : g[v]) {
      if (u != p) {
        get_path(g, u, v, path);
      }
    }
  }
}

bool check_swap(V<int>& path, V<int>& to) {
  if (int(path.S()) == 1) {
    return false;
  }

  V<int> new_from1(path.S(), 1 - to[path[0]]);
  FOR(i, 1, int(path.S())) {
    new_from1[i] = 1 - new_from1[i - 1];
  }
  V<int> new_from2(path.S(), 1 - to[path[0]]);
  new_from2[1] = new_from2[0];
  FOR(i, 2, int(path.S())) {
    new_from2[i] = 1 - new_from2[i - 1];
  }

  /*for (int v : path) {
    cout << v << ' ';
  }
  cout << endl;
  for (int v : new_from1) {
    cout << v << ' ';
  }
  cout << endl;
  for (int v : new_from2) {
    cout << v << ' ';
  }
  cout << endl << endl;*/

  return check_path2(path, new_from1, to) || check_path2(path, new_from2, to);
}

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

  int t;
  cin >> t;
  REP(f, t) {
    int n;
    cin >> n;

    V<int> from(n), to(n);
    string s1, s2;
    int red_from = 0;
    int red_to = 0;
    cin >> s1 >> s2;
    REP(i, n) {
      from[i] = s1[i] - '0';
      to[i] = s2[i] - '0';
      if (from[i] == 0) {
        red_from++;
      }
      if (to[i] == 0) {
        red_to++;
      }
    }

    V<V<int>> g(n);
    V<int> red_adj(n);
    V<int> black_adj(n);
    REP(i, n - 1) {
      int a, b;
      cin >> a >> b;
      a--, b--;

      g[a].EB(b);
      g[b].EB(a);

      if (to[b] == 0) {
        red_adj[a]++;
      }
      else {
        black_adj[a]++;
      }
      if (to[a] == 0) {
        red_adj[b]++;
      }
      else {
        black_adj[b]++;
      }
    }

    if (red_from == 0) {
      if (red_to == 0) {
        cout << "TAK\n";
      }
      else {
        cout << "NIE\n";
      }
      continue;
    }
    if (red_from == n) {
      if (red_to == n) {
        cout << "TAK\n";
      }
      else {
        cout << "NIE\n";
      }
      continue;
    }

    bool achievable = false;
    int start = -1;
    REP(v, n) {
      if (g[v].S() > 2) {
        start = v;
        if (to[v] == 0) {
          if (red_adj[v] > 0) {
            achievable = true;
          }
          for (int u : g[v]) {
            V<int> path;
            get_path(g, u, v, path);
            if (check_swap(path, to)) {
              achievable = true;
            }
          }
        }
        else {
          if (black_adj[v] > 0) {
            achievable = true;
          }
          for (int u : g[v]) {
            V<int> path;
            get_path(g, u, v, path);
            if (check_swap(path, to)) {
              achievable = true;
            }
          }
        }
      }
    }

    if (achievable) {
      cout << "TAK\n";
      continue;
    }

    if (start == -1) {
      start++;
      while (g[start].S() == 2) {
        start++;
      }
    }

    bool wrong = false;
    REP(v, n) {
      if (g[v].S() > 2 && from[v] != to[v]) {
        wrong = true;
      }
    }
    if (wrong) {
      cout << "NIE\n";
      continue;
    }

    V<V<int>> paths;
    generate_paths(g, start, -1, paths);

    for (V<int>& path : paths) {
      if (!check_path(path, from, to)) {
        wrong = true;
      }
    }

    if (wrong) {
      cout << "NIE\n";
    }
    else {
      cout << "TAK\n";
    }
  }
}