int find(int a){
	if(a == p[a]) return a;
	return p[a] = find(p[a]);
}

void merge(int a, int b){
	a = find(a), b = find(b);
	for(auto x : s[b]) s[a].insert(x);
	p[b] = a;
}

void merge(int a, int b){
	a = find(a), b = find(b);
	if(s[a].size() < s[b].size()) swap(a, b);
	for(auto x : s[b]) s[a].insert(x);
	p[b] = a;
}

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

int n, q, p[100100], c[100100], parent[100100];
set<int> s[100100];
stack<pair<int, int>> query;
stack<int> answer;

int find(int a){
    if(a == parent[a]) return a;
    return parent[a] = find(parent[a]);
}

void merge(int a, int b){
    a = find(a), b = find(b);
    if(s[a].size() < s[b].size()) swap(a, b); // small to large
    for(int x : s[b]) s[a].insert(x);
    parent[b] = a;
}

int main(){
    scanf("%d %d",&n,&q);
    for(int i=2;i<=n;i++) scanf("%d",p+i);
    for(int i=1;i<=n;i++) scanf("%d",c+i);
    for(int i=1;i<q+n;i++){
        int q, a; scanf("%d %d",&q,&a);
        query.push({q, a});
    }

    for(int i=1;i<=n;i++) parent[i] = i, s[i].insert(c[i]);
    while(!query.empty()){
        auto [q, a] = query.top(); query.pop();
        if(q == 1) merge(a, p[a]);
        else answer.push(s[find(a)].size());
    }

    while(!answer.empty()) printf("%d\n",answer.top()), answer.pop();
}

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

int n, c[100100], id[100100], lev[100100], ans = 1e9;
vector<int> v[100100];
map<int, int> mp[100100];

void dfs(int u, int p){
	id[u] = u; // map의 index 설정
    lev[u] = lev[p] + 1; // 루트부터 떨어진 거리
    mp[id[u]][c[u]] = lev[u]; // 현재 정점 또한 subtree에 속한 정점이다.

    for(auto x : v[u]) if(x != p){
        dfs(x, u);
        if(mp[id[x]].size() > mp[id[u]].size()) swap(id[x], id[u]); // small to large

        for(auto [c, h] : mp[id[x]]){
        	if(mp[id[u]].count(c)){ // 수가 중복되어 있다면
                ans = min(ans, mp[id[u]][c] + h - lev[u] * 2); // 두 점 사이의 거리를 계산하여 답을 갱신한다.
                mp[id[u]][c] = min(mp[id[u]][c], h); // 더 낮은 깊이로 값을 갱신해준다.
            }else{
                mp[id[u]][c] = h;
            }
        }
    }
}

int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",c+i);
    for(int i=1;i<n;i++){
        int a, b; scanf("%d %d",&a,&b);
        v[a].push_back(b), v[b].push_back(a);
    }
    dfs(1, 0);
    printf("%d",ans);
}

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

#define y1 JOODDAE

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template<class key, class value, class cmp = std::less<key>>
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;

int n, k, X[30030], Y[30030], x1[30030], x2[30030], y1[30030], y2[30030], col[300300];

set<int> s[30030];
ordered_map<int, int> x[30030], y[30030];

void Insert(int id, int k){
	s[id].insert(k);
	x[id][X[k]] = k;
	y[id][Y[k]] = k;
}

void Erase(int id, int k){
	s[id].erase(k);
	x[id].erase(X[k]);
	y[id].erase(Y[k]);
}

void solve(int id){ // id = 집합의 번호
	if(s[id].empty()) return; // 조각에 점이 없으면 더 이상 나누지 않는다.

	int u = *s[id].begin(); // 이번에 사용할 점을 찾는다.
	s[id].erase(u), x[id].erase(X[u]), y[id].erase(Y[u]); // 사용할 점은 집합에서 지워준다.

	++k; // 새로운 집합을 만든다.
	x1[k] = x1[id], x2[k] = x2[id], y1[k] = y1[id], y2[k] = y2[id];

	queue<int> q; // 새로운 집합으로 옮겨질 점을 저장할 자료구조

	if(col[id]){ // 검은색 조각이면 x좌표를 기준으로 나눈다.
		int cnt = x[id].order_of_key(X[u]);

		if(cnt <= s[id].size() / 2){ // 왼쪽 조각에 속한 점의 개수가 더 적으면
			x2[k] = x1[id] = X[u];
            // 왼쪽 조각에 속한 점을 나이브하게 찾는다.
			for(auto it=x[id].begin();it!=x[id].end() && it->first < X[u];it++) q.push(it->second);
		}else{ // 오른쪽 조각에 속한 점의 개수가 더 적으면
			x1[k] = x2[id] = X[u];
            // 오른쪽 조각에 속한 점을 나이브하게 찾는다.
			for(auto it=x[id].rbegin();it!=x[id].rend() && it->first > X[u];it++) q.push(it->second);
		}
	}else{ // 흰색 조각이면 y좌표를 기준으로 나눈다.
		int cnt = y[id].order_of_key(Y[u]);

		if(cnt <= s[id].size() / 2){ // 아래쪽 조각에 속한 점의 개수가 더 적으면
			y2[k] = y1[id] = Y[u];
            // 아래쪽 조각에 속한 점을 나이브하게 찾는다.
			for(auto it=y[id].begin();it!=y[id].end() && it->first < Y[u];it++) q.push(it->second);
		}else{ // 위쪽 조각에 속한 점의 개수가 더 적으면
			y1[k] = y2[id] = Y[u];
            // 위쪽 조각에 속한 점을 나이브하게 찾는다.
			for(auto it=y[id].rbegin();it!=y[id].rend() && it->first > Y[u];it++) q.push(it->second);
		}
	}

	while(!q.empty()){
		Insert(k, q.front()), Erase(id, q.front()); // 나이브하게 구한 옮겨질 점들을 집합에서 뺴주고, 삽입한다.
		q.pop();
	}

	col[k] = col[id] = !col[id]; // 색은 반전시킨다.
	solve(k), solve(id);
}

int main(){
	scanf("%d %d",x2,y2);
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%d %d",X+i,Y+i);

	for(int i=1;i<=n;i++) s[0].insert(i), x[0][X[i]] = y[0][Y[i]] = i;
	solve(0);

	int mx = 0, mn = 1e9;
	for(int i=0;i<=n;i++){
		mx = max(mx, (x2[i] - x1[i]) * (y2[i] - y1[i]));
		mn = min(mn, (x2[i] - x1[i]) * (y2[i] - y1[i]));
	}
	printf("%d %d",mx,mn);
}

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

int tc, n, a[200200], L[200200], R[200200];

bool unique(int l, int r, int x){ // [l, r] 구간내에 x번째 수가 unique하다면 true를 반환합니다.
	return L[x] < l && r < R[x];
}

bool solve(int l, int r){
	if(l >= r) return false; // 구간의 길이가 1이하면 non-boring한 구간입니다.

	int L = l, R = r;
	while(L <= R){ // 양방향 탐색
		if(unique(l, r, L)) return solve(l, L-1) || solve(L+1, r); // unique한 수를 찾았다면 두 구간으로 나눕니다.
		if(unique(l, r, R)) return solve(l, R-1) || solve(R+1, r);
		L++, R--;
	}

	return true; // 구간 내에 unique한 수가 없으므로 boring한 수열입니다.
}

int main(){
	cin.tie(0)->sync_with_stdio(0);
	cin >> tc;
	while(tc--){
		cin >> n;
		for(int i=1;i<=n;i++) cin >> a[i];

        // a[i]와 같은 값을 가지면서 왼쪽에서 가장 가까운 수의 위치를 L[i]에 저장하고, 오른쪽에서 가장 가까운 수의 위치를 R[i]에 저장합니다.
		map<int, int> mp;
		for(int i=1;i<=n;i++){
			int x = mp[a[i]];
			R[x] = i, L[i] = x;
			mp[a[i]] = i;
		}
		for(auto [x, y] : mp) R[y] = n+1;

		cout << (solve(1, n) ? "boring" : "non-boring") << "\n";
	}
}