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

const int MAX_N = 1e5 + 5;

vector <int> graf[MAX_N];

vector <int> kolejnosc_przechodzenia_wierzcholkow(MAX_N);

vector <bool> czy_czarny_na_poczatku(MAX_N);
vector <bool> czy_czarny_na_koncu(MAX_N);

vector <int> poczatkowe_skompresowane(MAX_N, -1);
vector <int> koncowe_skompresowane(MAX_N, -1);

int timer;

void DFS(int v, int poprzednik, bool czy_czarny, bool& ok)
{
	for(auto& sasiad : graf[v])
	{
		if(sasiad != poprzednik)
		{
			if(czy_czarny_na_koncu[sasiad] != !czy_czarny)
			{
				ok = true;
			}

			else
			{
				DFS(sasiad, v, !czy_czarny, ok);
			}
		}
	}
}

void DFS_sciezka(int v, int poprzednik)
{
	timer++;

	kolejnosc_przechodzenia_wierzcholkow[timer] = v;

	for(auto& sasiad : graf[v])
	{
		if(sasiad != poprzednik)
		{
			DFS_sciezka(sasiad, v);
		}
	}
}

void policz_ilosci(int& ilosc_poczatkowa_czarne, int& ilosc_poczatkowa_czerwone, int& ilosc_koncowa_czarne, int& ilosc_koncowa_czerwone, int n)
{
	int indeks_poczatek = 0;
	int indeks_koniec = 0;

	for(int i = 1; i <= n; i++)
	{
		int v = kolejnosc_przechodzenia_wierzcholkow[i];

		// if((indeks_poczatek == 0) || (indeks_poczatek > 0 && poczatkowe_skompresowane[indeks_poczatek - 1] != czy_czarny_na_poczatku[v]))
		// {
			poczatkowe_skompresowane[indeks_poczatek] = czy_czarny_na_poczatku[v];

			indeks_poczatek++;
		// }

		if(czy_czarny_na_poczatku[v])
		{
			ilosc_poczatkowa_czarne++;
		}

		else
		{
			ilosc_poczatkowa_czerwone++;
		}

		while(i < n && czy_czarny_na_poczatku[kolejnosc_przechodzenia_wierzcholkow[i + 1]] == czy_czarny_na_poczatku[v])
		{
			i++;
		}
	}

	for(int i = 1; i <= n; i++)
	{
		int v = kolejnosc_przechodzenia_wierzcholkow[i];

		// if((indeks_koniec == 0) || (indeks_koniec > 0 && koncowe_skompresowane[indeks_koniec - 1] != czy_czarny_na_poczatku[v]))
		// {
			koncowe_skompresowane[indeks_koniec] = czy_czarny_na_koncu[v];

			indeks_koniec++;
		// }

		if(czy_czarny_na_koncu[v])
		{
			ilosc_koncowa_czarne++;
		}

		else
		{
			ilosc_koncowa_czerwone++;
		}

		while(i < n && czy_czarny_na_koncu[kolejnosc_przechodzenia_wierzcholkow[i + 1]] == czy_czarny_na_koncu[v])
		{
			i++;
		}
	}
}

void wyczysc(int n)
{
	timer = 0;

	for(int i = 1; i <= n; i++)
	{
		graf[i].clear();

		poczatkowe_skompresowane[i] = -1;
		koncowe_skompresowane[i] = -1;

		czy_czarny_na_poczatku[i] = false;
		czy_czarny_na_koncu[i] = false;
	}
}

void solve()
{
	int n;
	cin >> n;

	for(int i = 1; i <= n; i++)
	{
		char znak;
		cin >> znak;

		if(znak == '1')
		{
			czy_czarny_na_poczatku[i] = true;
		}
	}

	for(int i = 1; i <= n; i++)
	{
		char znak;
		cin >> znak;

		if(znak == '1')
		{
			czy_czarny_na_koncu[i] = true;
		}
	}

	for(int i = 0; i < n - 1; i++)
	{
		int a, b;
		cin >> a >> b;

		graf[a].push_back(b);
		graf[b].push_back(a);
	}

	bool ok = false;

	if(czy_czarny_na_poczatku == czy_czarny_na_koncu)
	{
		ok = true;
	}

	else
	{
		int max_stopien = 0;

		for(int i = 1; i <= n; i++)
		{
			int stopien = (int) graf[i].size();

			max_stopien = max(max_stopien, stopien);
		}

		if(max_stopien >= 3)
		{
			bool czy_jest_czerwone = false;
			bool czy_jest_czarne = false;

			for(int i = 1; i <= n; i++)
			{
				if(czy_czarny_na_poczatku[i])
				{
					czy_jest_czarne = true;
				}

				else
				{
					czy_jest_czerwone = true;
				}
			}

			if(czy_jest_czerwone && czy_jest_czarne)
			{
				DFS(1, 0, czy_czarny_na_koncu[1], ok);
			}
		}

		if(max_stopien <= 2 && n > 1)
		{
			for(int i = 1; i <= n; i++)
			{
				int stopien = (int) graf[i].size();

				// czy wierzcholek jest lisciem
				if(stopien == 1)
				{
					DFS_sciezka(i, 0);

					break;
				}
			}

			int ilosc_poczatkowa_czarne = 0;
			int ilosc_poczatkowa_czerwone = 0;

			int ilosc_koncowa_czarne = 0;
			int ilosc_koncowa_czerwone = 0;

			policz_ilosci(ilosc_poczatkowa_czarne, ilosc_poczatkowa_czerwone, ilosc_koncowa_czarne, ilosc_koncowa_czerwone, n);

			if(((ilosc_koncowa_czarne < ilosc_poczatkowa_czarne) && (ilosc_koncowa_czerwone <= ilosc_poczatkowa_czerwone)) || ((ilosc_koncowa_czarne <= ilosc_poczatkowa_czarne) && (ilosc_koncowa_czerwone < ilosc_poczatkowa_czerwone)))
			{
				ok = true;
			}

			else
			{
				if(poczatkowe_skompresowane == koncowe_skompresowane)
				{
					ok = true;
				}
			}
		}
	}

	wyczysc(n);

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

	else
	{
		cout << "NIE\n";
	}
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);

	int t;
	cin >> t;

	while(t--)
	{
		solve();
	}

	return 0;
}