#include <cstdio>
#include <cassert>
#include <vector>
#include <tuple>
#include <unordered_set>
#include <queue>
#include <chrono>

using namespace std;

const int maxn = 100005;
int n;
char ca[maxn];
char cb[maxn];

class node {
public:
        int nr;
        int edge_n;
        vector<int> e;
};

vector<node> t;

void print_tree()
{
        printf("\n********************\n");
        for(int i = 1; i <= n; ++i) {
                printf("(%d ca:%c  cb:%c)", t[i].nr, ca[i], cb[i]);
                for(int j = 0; j < t[i].edge_n; ++j) {
                        printf(" -> %d", t[i].e[j]);
                }
                printf("\n");
        }
//        if (r[k] == 0) {
//               printf("NIE\n");
//        } else {
//               printf("TAK\n");
//        }
}

bool same_colors_in_input()
{
        char c = ca[1];

        for(int i = 1; i <= n; ++i) {
                if (ca[i] != c) {
                        return false;
                }
        }
        return true;
}

bool input_equal_output()
{
        for(int i = 1; i <= n; ++i) {
                if (ca[i] != cb[i]) {
                        return false;
                }
        }
        return true;
}

bool adjacent_nodes_have_different_color_than_me_at_finish(int k)
{
        char mycolor = cb[t[k].nr];

        for(int i = 0; i < t[k].edge_n; ++i) {
                if (cb[t[k].e[i]] == mycolor) {
                        return false;
                }
        }
        return true;
}

bool exists_node_with_morethan2_edges_with_diff_adj_colours()
{
        for(int i = 1; i <= n; ++i) {
                if (t[i].edge_n > 2) {
                        if (!adjacent_nodes_have_different_color_than_me_at_finish(i)) {
                                return true;
                        }
                }
        }
        return false;
}


bool exists_node_with_morethan2_edges()
{
        for(int i = 1; i <= n; ++i) {
                if (t[i].edge_n > 2) {
                        return true;
                }
        }
        return false;
}

int calc_changes(int k, int prev)
{
        int res = 0;
        char lastc;

        lastc = cb[k];
        while(1) {
                int next = t[k].e[0];
                if (next == prev) {
                        if (t[k].edge_n == 1) {
                                break;
                        }
                        next = t[k].e[1];
                }
                prev = k;
                k = next;
                if (cb[k] != lastc) {
                        res++;
                }
                lastc = cb[k];
        }
        return res;
}

int calc_len(int k, int prev)
{
        int res = 0;

        while(1) {
                int next = t[k].e[0];
                if (next == prev) {
                        if (t[k].edge_n == 1) {
                                break;
                        }
                        next = t[k].e[1];
                }
                prev = k;
                k = next;
                res++;
        }
        return res;
}


// if adj of k have different colours return true
// 
// exists adj of k (called j) that have another adj (!= k) having same colur as  j
bool check_node(int k)
{
        char c = cb[t[k].e[0]];


        for(int i = 0; i < t[k].edge_n; ++i) {
                if (cb[t[k].e[i]] != c) {
                        return false;
                }
        }

        // all adj have same colours
        for(int i = 0; i < t[k].edge_n; ++i) {
                int j = t[k].e[i];
                for(int l = 0; l < t[j].edge_n; ++l) {
                        int m = t[j].e[l];
                        if (m != k) {
                                if (cb[m] == cb[j]) {
                                        return true;
                                }
                                for(int i2 = 0; i2 < t[m].edge_n; ++i2) {
                                        int j2 = t[m].e[i2];
                                        if (j2 != m) {
                                                if (cb[j2] == cb[m]) {
                                                        return true;
                                                }
                                        }
                                }
                                if (calc_changes(m, j) < calc_len(m, j)) {
                                        return true;
                                }
                        }
                }
        }
        return false;
}

bool check_nodes_with_morethan2_edges()
{
        for(int i = 1; i <= n; ++i) {
                if (t[i].edge_n > 2) {
                        if (check_node(i)) {
                                return true;
                        }
                }
        }
        return false;
}

int first()
{
        for(int k = 1; k <= n; ++k) {
                if (t[k].edge_n == 1) {
                        return k;
                }
        }
        return 1;
}

int calc_changes(char *c)
{
        int k;
        int res = 0;
        char lastc;
        int prev;


        for(k = 1; k <= n; ++k) {
                if (t[k].edge_n == 1) {
                        break;
                }
        }

        lastc = c[k];
        prev = k;
        k = t[k].e[0];
        if (c[k] != lastc) {
                res++;
        }
        lastc = c[k];

        while(1) {
                int next = t[k].e[0];
                if (next == prev) {
                        if (t[k].edge_n == 1) {
                                break;
                        }
                        next = t[k].e[1];
                }
                prev = k;
                k = next;
                if (c[k] != lastc) {
                        res++;
                }
                lastc = c[k];
        }
        return res;
}


int main()
{
        int nt;

        scanf("%d\n", &nt);
        for(int i = 0; i < nt; ++i) {
                node nd;
                scanf("%d\n", &n);
                scanf("%s\n", ca);
                scanf("%s\n", cb);
                
                for(int j = n; j > 0; --j) {
                        ca[j] = ca[j-1];
                        cb[j] = cb[j-1];
                }

                t.clear();
                t.resize(n+1);
                for(int j = 1; j <= n; ++j) {
                        t[j].nr=j;
                        t[j].edge_n=0;
                        t[j].e.clear();
                }

                for(int j = 0; j < n-1; ++j) {
                        int a,b;
                        scanf("%d %d\n", &a, &b);
                        t[a].edge_n++;
                        t[a].e.push_back(b);
                        t[b].edge_n++;
                        t[b].e.push_back(a);
                }
        

                if (input_equal_output()) {
                        printf("TAK\n");
                        continue;
                }

                if (same_colors_in_input()) {
                        printf("NIE\n");
                        continue;
                }

                if (exists_node_with_morethan2_edges_with_diff_adj_colours()) {
                        printf("TAK\n");
                        continue;
                }
                // nie ma węzłow o więcej niż 2 s±siadach
                // albo
                // s± węzły x, o więcej niż 2 s±siadach, ale wtedy wszyscy s±siedzi maj± ten sam kolor, inny niż węzeł x

                if (exists_node_with_morethan2_edges()) {
                        // funkcja bada węzły o więcej niż 2 s±siadach
                        // jesli taki węzeł i ma s±siada j
                        // oraz węzeł j ma s±siada k (innego niż i) w tym samym kolorze co j to true
                        // oraz węzeł j ma s±siada k (innego niż i) w innym kolorze niż j, ale ma kolejnego s±siada w tym samym kolorze co k to true

                        if (check_nodes_with_morethan2_edges()) {
                               printf("TAK\n");   
                        } else {
                               printf("NIE\n");
                        }
                        continue;
                }
                
                //4) je¶li istniej± węzły (i) o > 2 s±siadach i wszyscy sasiedzi (j) maj± inny kolor niż węzeł to:
                  // 1) je¶li istnieje s±siad j który ma s±siada (k) (innego niż i) w tym samym kolorze to TAK
                  // 2) je¶łi istnieje s±siad j którym ma s±siada k, oraz k ma kolejnego s±siada m w tym samym kolorze co k to TAK
                  // 3) w p.p. NIE
                // 5) pozostały już tylko przypadki zdegenerowane do prostej
                int chga = calc_changes(ca);
                int chgb = calc_changes(cb);
                if (chga < chgb) {
                        printf("NIE\n");
                        continue;
                }
                if (chga > chgb) {
                        printf("TAK\n");
                        continue;
                }
                if (ca[first()] == cb[first()]) {
                        printf("TAK\n");
                } else {
                        printf("NIE\n");
                }

        }
        return 0;
}