#include<bits/stdc++.h>
using namespace std;
 
int main() {
	int t; cin >> t;
	while (t--) {
		int X, Y, K;
		cin >> X >> Y >> K;
		int M = min(X, Y);
		cout << "0 0 " << M << " " << M << endl;
		cout << "0 " << M << " " << M << " 0" << endl;
	}
}

#include <bits/stdc++.h>
 
using namespace std;
 
int main() {
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n;
    vector<long long> a(n);
    for (auto& x : a) cin >> x;
    
    long long ans = 1e18;
    
    auto upd = [&](vector<long long> a) {
      sort(a.begin(), a.end());
      for (int i = 1; i < (int)a.size(); ++i)
        if (a[i - 1] == a[i]) return;
      long long res = 0;
      for (int i = 0; i < (int)a.size(); i += 2)
        res = max(res, a[i + 1] - a[i]);
      ans = min(ans, res);
    };
    
    if (n % 2 == 0) {
      upd(a);
      cout << ans << '\n';
      continue;
    }
    
    for (int i = 0; i < n; ++i) {
      for (int x : {-1, 1}) {
        a.push_back(a[i] + x);
        upd(a);
        a.pop_back();
      }
    }
    
    cout << ans << '\n';
  }
}

#include<bits/stdc++.h>
 
using namespace std;
 
const int N = 400043;
char buf[N];
 
bool can(const string& s, int k)
{
    int n = s.size();
    vector<int> used(n);
    for(int i = n - 1; i >= 0; i--)
        if(k > 0 && s[i] == '1')
        {
            used[i] = 1;
            k--;
        }
    int cur = 0;
    for(int i = 0; i < n; i++)
        if(used[i])
        {
            cur--;
            if(cur < 0) return false;
        }
        else cur++;
    return true;
}   
 
void solve()
{
    int n;
    scanf("%d", &n);
    scanf("%s", buf);                         
    if(n == 1)
    {
        puts("1");
        return;
    }
    string s = buf;
    int count_1 = 0;
    for(auto x : s) if (x == '1') count_1++;
    int l = 1;
    int r = count_1 + 1;
    while(r - l > 1)
    {
        int mid = (l + r) / 2;
        if(can(s, mid))
            l = mid;
        else
            r = mid;
    }
    long long ans = 0;
    for(int i = n - 1; i >= 0; i--)
        if(s[i] == '1' && l > 0)
            l--;
        else
            ans += (i + 1);
    printf("%lld\n", ans);
}
 
int main()
{
    int t;
    scanf("%d", &t);
    for(int i = 0; i < t; i++)
        solve();
}

#include<bits/stdc++.h>
 
using namespace std;
 
const int MOD = 998244353;
 
int n;
 
vector<long long> a;
vector<long long> pa;
vector<long long> ppa;
vector<long long> start;
vector<long long> block;
vector<long long> pblock;
 
vector<long long> prefix_sums(vector<long long> v)
{
 	int k = v.size();
 	vector<long long> res(k + 1);
 	for(int i = 0; i < k; i++) res[i + 1] = res[i] + v[i];
 	return res;
}
 
long long get_partial(int l, int r1, int r2)
{
	// s(l, r1) + s(l, r1 + 1) + ... + s(l, r2 - 1)
 	if(r2 <= r1) return 0ll;
 	int cnt = r2 - r1;
 	long long rem = pa[l] * cnt;
 	long long add = ppa[r2 + 1] - ppa[r1 + 1];
 	return add - rem;
}
 
pair<int, int> convert(long long i)
{
	int idx = upper_bound(start.begin(), start.end(), i) - start.begin() - 1;
	pair<int, int> res = {idx, i - start[idx] + idx};
	return res; 	
}
 
long long query(long long l, long long r)
{
	pair<int, int> lf = convert(l);
	pair<int, int> rg = convert(r);
	long long res = pblock[rg.first + 1] - pblock[lf.first];
	if(lf.second != lf.first) res -= get_partial(lf.first, lf.first, lf.second);
	if(rg.second != n - 1) res -= get_partial(rg.first, rg.second + 1, n);
	return res;	
}
 
int main()
{
	scanf("%d", &n);
	a.resize(n);
	for(int i = 0; i < n; i++) scanf("%lld", &a[i]);
	pa = prefix_sums(a);
	ppa = prefix_sums(pa);
	start = {0};
	for(int i = n; i >= 1; i--)
		start.push_back(start.back() + i);
	block.resize(n);
	for(int i = 0; i < n; i++)
		block[i] = get_partial(i, i, n);
	pblock = prefix_sums(block);
	int q;
	scanf("%d", &q);
	for(int i = 0; i < q; i++)
	{
	 	long long l, r;
	 	scanf("%lld %lld", &l, &r);
	 	printf("%lld\n", query(l - 1, r - 1));
	}
 
}

#include <bits/stdc++.h>
 
using namespace std;
 
#define sz(a) int((a).size())
 
template<typename T = int>
struct Dinic {
  struct edge {
    int u, rev;
    T cap, flow;
  };
  
  int n, s, t;
  T flow;
  vector<int> lst;
  vector<int> d;
  vector<vector<edge>> g;
  
  Dinic() {}
  
  Dinic(int n, int s, int t) : n(n), s(s), t(t) {
    g.resize(n);
    d.resize(n);
    lst.resize(n);
    flow = 0;
  }
 
  void add_edge(int v, int u, T cap, bool directed = true) {
    g[v].push_back({u, sz(g[u]), cap, 0});
    g[u].push_back({v, sz(g[v]) - 1, directed ? 0 : cap, 0});
  }
 
  T dfs(int v, T flow) {
    if (v == t) return flow;
    if (flow == 0) return 0;
    T result = 0;
    for (; lst[v] < sz(g[v]); ++lst[v]) {
      edge& e = g[v][lst[v]];
      if (d[e.u] != d[v] + 1) continue;
      T add = dfs(e.u, min(flow, e.cap - e.flow));
      if (add > 0) {
        result += add;
        flow -= add;
        e.flow += add;
        g[e.u][e.rev].flow -= add;
      }
      if (flow == 0) break;
    }
    return result;
  }
 
  bool bfs() {
    fill(d.begin(), d.end(), -1);
    queue<int> q({s});
    d[s] = 0;
    while (!q.empty() && d[t] == -1) {
      int v = q.front(); q.pop();
      for (auto& e : g[v]) {
        if (d[e.u] == -1 && e.cap - e.flow > 0) {
          q.push(e.u);
          d[e.u] = d[v] + 1;
        }
      }
    }
    return d[t] != -1;
  }
 
  T calc() {
    T add;
    while (bfs()) {
      fill(lst.begin(), lst.end(), 0);
      while((add = dfs(s, numeric_limits<T>::max())) > 0)
        flow += add;
    }
    return flow;
  }
};
 
const int B = 60;
const int INF = 1e9;
 
int main() {
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n;
    int s = n + B, t = n + B + 1;
    Dinic mf(t + 1, s, t);
    for (int i = 0; i < n; ++i) {
      long long x;
      cin >> x;
      mf.add_edge(s, i, 1);
      for (int j = 0; j < B; ++j) {
        if ((x >> j) & 1) mf.add_edge(i, j + n, INF);
      }
    }
    for (int i = 0; i < B; ++i) mf.add_edge(i + n, t, 1);
    cout << n - mf.calc() << '\n';
  }
}

#include <bits/stdc++.h>
 
#define forn(i, n) for (int i = 0; i < int(n); i++)
 
using namespace std;
 
const int P = 2000 + 5;
 
struct item{
	int p, t;
};
 
struct minstack {
	stack<item> st;
	stack<array<int, P>> dp;
	int get(int p) {return dp.empty() ? 0 : dp.top()[p];}
	bool empty() {return st.empty();}
	int size() {return st.size();}
	void push(item it) {
		if (empty()){
		    dp.push({});
		    for (int i = 0; i < P; ++i)
		        dp.top()[i] = 0;
		}
		else{
		    dp.push(dp.top());
		}
		st.push(it);
		for (int i = P - it.p - 1; i >= 0; --i)
			dp.top()[i + it.p] = max(dp.top()[i + it.p], dp.top()[i] + it.t);
	}
	void pop() {
		st.pop();
		dp.pop();
	}
	item top() {
		return st.top();
	}
	void swap(minstack &x) {
		st.swap(x.st);
		dp.swap(x.dp);
	}
};
 
struct mindeque {
	minstack l, r, t;
	void rebalance() {
		bool f = false;
		if (r.empty()) {f = true; l.swap(r);}
		int sz = r.size() / 2;
		while (sz--) {t.push(r.top()); r.pop();}
		while (!r.empty()) {l.push(r.top()); r.pop();}
		while (!t.empty()) {r.push(t.top()); t.pop();}
		if (f) l.swap(r);
	}
	int get(int p) {
		int ans = 0;
		for (int i = 0; i <= p; ++i)
			ans = max(ans, l.get(i) + r.get(p - i));
		return ans;
	}
	bool empty() {return l.empty() && r.empty();}
	int size() {return l.size() + r.size();}
	void push_front(item it) {l.push(it);}
	void push_back(item it) {r.push(it);}
	void pop_front() {if (l.empty()) rebalance(); l.pop();}
	void pop_back() {if (r.empty()) rebalance(); r.pop();}
	item front() {if (l.empty()) rebalance(); return l.top();}
	item back() {if (r.empty()) rebalance(); return r.top();}
	void swap(mindeque &x) {l.swap(x.l); r.swap(x.r);}
};
 
struct edge{
	int u, tp, p, t;
};
 
struct query{
	int i, p;
};
 
vector<vector<edge>> g;
vector<vector<query>> qs;
vector<int> ans;
mindeque ks;
 
void dfs(int v){
	for (auto& [i, p] : qs[v]){
		ans[i] = ks.get(p);
	}
	for (auto& [u, tp, p, t] : g[v]){
		if (tp == 0){
			dfs(u);
		}
		else if (tp == -1){
		    auto it = ks.front();
		    ks.pop_front();
			dfs(u);
			ks.push_front({it.p, it.t});
		}
		else{
			ks.push_back({p, t});
			dfs(u);
			ks.pop_back();
		}
	}
}
 
int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	int q;
	cin >> q;
	vector<int> st(1);
	vector<int> where(q, -1);
	int cnt = 1, cnt_real = 1;
	where[0] = 0;
	g.push_back({});
	qs.push_back({});
	
	auto copy_shop = [&](int x, bool real){
		g.push_back({});
		qs.push_back({});
		st.push_back(st[x]);
		if (real){
			where[cnt_real] = cnt;
			++cnt_real;
		}
		++cnt;
	};
	
	forn(i, q){
		int tp, x;
		cin >> tp >> x;
		--x;
		int v = where[x], u = -1;
		if (tp != 4){
			copy_shop(v, tp == 1);
			u = cnt - 1;
		}
		if (tp == 1){
			g[v].push_back({u, 0, -1, -1});
			continue;
		}
		if (tp == 3){
			g[v].push_back({u, -1, -1, -1});
			++st[u];
			where[x] = u;
			continue;
		}
		int p;
		cin >> p;
		if (tp == 4){
			qs[v].push_back({i, p});
			continue;
		}
		int t;
		cin >> t;
		g[v].push_back({u, 1, p, t});
		where[x] = u;
	}
	
	ans.assign(q, -1);
	dfs(0);
	forn(i, q) if (ans[i] != -1) cout << ans[i] << '\n';
	return 0;
}

for _ in range(int(input())):
	s = input()
	t = input()

	lcp = 0
	n = len(s)
	m = len(t)
	for i in range(1, min(n, m) + 1):
		if s[:i] == t[:i]:
			lcp = i
	print(n + m - max(lcp, 1) + 1)

#include<bits/stdc++.h>

using namespace std;

const int MOD = int(1e9) + 7;

int main() {
	int t; cin >> t;
	vector<int> ks(t);
	for (int _ = 0; _ < 2; _++)
		for (int i = 0; i < t; i++)
			cin >> ks[i];
	
	vector<int> ans(1 + *max_element(ks.begin(), ks.end()), 1);
	for (int i = 1; i < (int)ans.size(); i++)
		ans[i] = (2LL * ans[i - 1]) % MOD;
	
	for (int k : ks)
		cout << ans[k] << '\n';
	return 0;
}

for _ in range(int(input())):
	n, k = map(int, input().split())
	a = list(map(int, input().split()))
	a.sort()
	ans = 0
	j = 0
	for i in range(n):
		j = max(i, j)
		while j + 1 < n and a[j + 1] - a[j] <= 1 and a[j + 1] - a[i] < k:
			j += 1
		ans = max(ans, j - i + 1)
	print(ans)

#include<bits/stdc++.h>
 
using namespace std;
 
#define fore(i, l, r) for(int i = int(l); i < int(r); i++)
#define sz(a) int((a).size())
 
typedef long long li;
 
const int INF = int(1e9);
const li INF64 = li(1e18);
 
int n, m;
vector<int> rs;
 
bool read() {
	if(!(cin >> n >> m))
		return false;
	rs.resize(n);
	fore (i, 0, n)
		cin >> rs[i];
	return true;
}
 
struct LazySum {
	vector<int> ps;
	LazySum(int n) : ps(n, 0) {}
	
	//[l, r]
	void add(int l, int r, int val) {
		if (l > r) return;
		ps[l] += val;
		ps[r + 1] -= val;
	}
	void pushToAndClear(vector<int> &d) {
		int sum = 0;
		fore (i, 0, sz(ps)) {
			sum += ps[i];
			ps[i] = 0;
			if (i < sz(d))
				d[i] += sum;
		}
	}
};
 
void solve() {
	LazySum ls(m + 2);
	vector<int> d(m + 1, -INF);
	d[0] = 0;
 
	int cntP = 0;
	for (int r : rs) {
		if (r == 0) {
			ls.pushToAndClear(d);
			for (int i = m; i > 0; i--)
				d[i] = max(d[i], d[i - 1]);
			cntP++;
			continue;
		}
		if (r > 0)
			ls.add(r, m, 1);
		else
			ls.add(0, cntP + r, 1);
	}
	ls.pushToAndClear(d);
	cout << *max_element(d.begin(), d.end()) << endl;
}
 
int main() {
#ifdef _DEBUG
	freopen("input.txt", "r", stdin);
	int tt = clock();
#endif
	ios_base::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	cout << fixed << setprecision(15);
	
	if(read()) {
		solve();
		
#ifdef _DEBUG
		cerr << "TIME = " << clock() - tt << endl;
		tt = clock();
#endif
	}
	return 0;
}

n, m = map(int, input().split())
rs = map(int, input().split())

d = [-int(1e9)] * (m + 1)
d[0] = 0
add = [0] * (m + 2)
def addSegment(l, r):
    if l <= r:
        add[l] += 1
        add[r + 1] -= 1

def pushAll():
    sum = 0
    for i in range(m + 1):
        sum += add[i]
        d[i] += sum
    for i in range(m + 2):
        add[i] = 0

cntPoints = 0
for r in rs:
    if r == 0:
        pushAll()
        for i in range(m, 0, -1):
            d[i] = max(d[i], d[i - 1])
        cntPoints += 1
    else:
        lf, rg = 0, 0
        if (r > 0):
            lf = min(r, m + 1)
            rg = m
        else:
            lf = 0
            rg = max(-1, cntPoints + r)
        addSegment(lf, rg)
pushAll()
print(max(d))

#include <bits/stdc++.h>
 
using namespace std;
 
const int MOD = 998244353;
 
int add(int x, int y) {
  x += y;
  if (x >= MOD) x -= MOD;
  return x;
}
 
int mul(int x, int y) {
  return x * 1LL * y % MOD;
}
 
int main() {
  int n, m;
  cin >> n >> m;
  vector<vector<int>> ways(m + 1, vector<int>(m + 1));
  ways[0][0] = 1;
  for (int i = 0; i < m; ++i) {
    for (int j = 0; j <= i; ++j) {
      ways[i + 1][j + 1] = add(ways[i + 1][j + 1], ways[i][j]);
      if (j) ways[i + 1][j - 1] = add(ways[i + 1][j - 1], ways[i][j]);
    }
  }
  
  vector<vector<int>> dp(n + 1, vector<int>(m + 1));
  dp[0][0] = 1;
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j <= m; ++j) {
      for (int k = 0; k <= m; ++k) {
        int nj = i ? j - k : j + k;
        if (0 <= nj && nj <= m) {
          dp[i + 1][nj] = add(dp[i + 1][nj], mul(dp[i][j], ways[m][k]));
        }
      }
    }
  }
  cout << dp[n][0] << '\n';
}

#include<bits/stdc++.h>
 
using namespace std;
 
const int N = 300043;
 
string choice = "xy";
string sign = "+-";
 
int qs[N][2];
string ans[N];
int n, q;
vector<int> g[N];
int color[N];
 
void pair_queries(int q1, int q2)
{
 	if(q1 > q2) swap(q1, q2);
 	for(int i = 0; i < 2; i++)
 		for(int j = 0; j < 2; j++)
 			if(qs[q1][i] == qs[q2][j])
 			{
 			 	ans[q1] = { choice[i], sign[0] };
 			 	ans[q2] = { choice[j], sign[1] };
 			 	return;
 			}
}
 
bool dfs(int v, int pe = -1)
{
 	// return true if parent edge still exists
 	color[v] = 1;
 	vector<int> edge_nums;
 	for(auto e : g[v])
 	{
 		int u = v ^ qs[e][0] ^ qs[e][1];
 		if(color[u] == 1) continue;
 		if(color[u] == 0)
 		{
 			if(dfs(u, e))
 				edge_nums.push_back(e);
 		}
 		else
 			edge_nums.push_back(e);
 	}
 	bool res = true;
 	if(edge_nums.size() % 2 != 0)
 	{
 		if(pe != -1) edge_nums.push_back(pe);
 		else edge_nums.pop_back();
 		res = false;
 	}
 	for(int i = 0; i < edge_nums.size(); i += 2)
 		pair_queries(edge_nums[i], edge_nums[i + 1]);
 	color[v] = 2;
 	return res;
}
 
int main()
{
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	cin >> n >> q;
	for(int i = 0; i < q; i++)
	{
	 	cin >> qs[i][0] >> qs[i][1];
	 	--qs[i][0];
	 	--qs[i][1];
	 	g[qs[i][0]].push_back(i);
	 	g[qs[i][1]].push_back(i);
	 	ans[i] = "x+";
	}
	for(int i = 0; i < n; i++)
		if(color[i] == 0)
			dfs(i);
	for(int i = 0; i < q; i++) cout << ans[i] << endl;
}

#include <bits/stdc++.h>
 
#define forn(i, n) for (int i = 0; i < int(n); i++)
 
using namespace std;
 
struct query{
	int t, v;
};
 
int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	int m;
	cin >> m;
	vector<query> q(m);
	forn(i, m) cin >> q[i].t >> q[i].v;
	
	vector<pair<int, int>> xs;
	forn(i, m) xs.push_back({q[i].v, i});
	sort(xs.rbegin(), xs.rend());
	forn(i, m) q[i].v = xs.rend() - lower_bound(xs.rbegin(), xs.rend(), make_pair(q[i].v, i)) - 1;
	
	const int p = sqrt(m + 10);
	const int siz = (m + p - 1) / p;
	
	vector<int> tp(m);
	vector<int> val(m);
	vector<vector<long long>> dp(p, vector<long long>(2 * siz + 1));
	vector<int> blbal(p);
	
	auto upd = [&](const query &q){
		tp[q.v] = q.t;
		val[q.v] = xs[q.v].first;
		blbal[q.v / siz] += q.t == 1 ? 1 : -1;
	};
	
	auto recalc = [&](int b){
		dp[b].assign(2 * siz + 1, 0);
		int bal = 0;
		for (int i = b * siz; i < m && i < (b + 1) * siz; ++i){
			if (tp[i] == 1){
				dp[b][0] += val[i];
				dp[b][0] += val[i];
				dp[b][-bal + siz] -= val[i];
				++bal;
			}
			else if (tp[i] == 2){
				dp[b][-bal + 1 + siz] += val[i];
				--bal;
			}
		}
		forn(i, 2 * siz){
			dp[b][i + 1] += dp[b][i];
		}
	};
	
	auto get = [&](int b, int bal){
		bal += siz;
		if (bal < 0) return dp[b][0];
		if (bal >= 2 * siz + 1) return dp[b].back();
		return dp[b][bal];
	};
	
	for (auto it : q){
		upd(it);
		recalc(it.v / siz);
		int bal = 0;
		long long ans = 0;
		for (int i = 0; i * siz < m; ++i){
			ans += get(i, bal);
			bal += blbal[i];
		}
		cout << ans << '\n';
	}
	
	return 0;
}

t = int(input())
for i in range(t):
    n = int(input())
    x = list(map(int, input().split()))
    if n > 2 or x[0] + 1 == x[-1]:
        print('NO')
    else:
        print('YES')

#include <bits/stdc++.h>
 
using namespace std;
 
int main() {
  int t;
  cin >> t;
  while (t--) {
    int l, r, L, R;
    cin >> l >> r >> L >> R;
    int inter = min(r, R) - max(l, L) + 1;
    int ans = inter - 1;
    if (inter <= 0) {
      ans = 1;
    } else {
      ans += (l != L);
      ans += (r != R);
    }
    cout << ans << '\n';
  }
}

fun main() {
    repeat(readln().toInt()) {
        val (n, k) = readln().split(" ").map { it.toInt() }
        val a = readln().split(" ").map { it.toInt() }.sortedDescending().toIntArray()

        var score = 0L
        var rem = k
        for (i in a.indices) {
            if (i % 2 == 0) {
                score += a[i]
            }
            else {
                val needed = minOf(rem, a[i - 1] - a[i])
                a[i] += needed
                rem -= needed
                score -= a[i]
            }
        }
        println(score)
    }
}

#include <bits/stdc++.h>
 
using namespace std;
 
const int INF = 1e9;
const string vars[] = {"BG", "BR", "BY", "GR", "GY", "RY"};
 
int main() {
  ios::sync_with_stdio(false); cin.tie(0);
  int t;
  cin >> t;
  while (t--) {
    int n, q;
    cin >> n >> q;
    vector<int> a(n);
    for (int i = 0; i < n; ++i) {
      char s[5];
      cin >> s;
      a[i] = find(vars, vars + 6, s) - vars;
    }
    vector<vector<int>> lf(n), rg(n);
    for (int o = 0; o < 2; ++o) {
      vector<int> last(6, -INF);
      for (int i = 0; i < n; ++i) {
        last[a[i]] = (o ? n - i - 1 : i);
        (o ? rg[n - i - 1] : lf[i]) = last;
      }
      reverse(a.begin(), a.end());
    }
    while (q--) {
      int x, y;
      cin >> x >> y;
      --x; --y;
      int ans = INF;
      for (int j = 0; j < 6; ++j) {
        if (a[x] + j != 5 && j + a[y] != 5) {
          ans = min(ans, abs(x - lf[x][j]) + abs(lf[x][j] - y));
          ans = min(ans, abs(x - rg[x][j]) + abs(rg[x][j] - y));
        }
      }
      if (ans > INF / 2) ans = -1;
      cout << ans << '\n';
    }
  }
}

#include<bits/stdc++.h>
 
using namespace std;
 
const int MOD = 998244353;
 
const int N = int(1e7) + 43;
 
int lp[N + 1];
vector<int> pr;
int idx[N + 1];
 
void precalc()
{
	for (int i = 2; i <= N; i++) 
	{
		if (lp[i] == 0) 
		{
			lp[i] = i;
			pr.push_back(i);
		}
		for (int j = 0; j < pr.size() && pr[j] <= lp[i] && i * 1ll * pr[j] <= N; ++j)
			lp[i * pr[j]] = pr[j];
	}
	for (int i = 0; i < pr.size(); i++)
		idx[pr[i]] = i + 1; 
}
 
int get(int x)
{
	if(x == 1) return 1;
 	x = lp[x];
 	if(x == 2)
 		return 0;
 	else return idx[x]; 		
}
 
void solve()
{             
	int n;
	scanf("%d", &n);
	int res = 0;
	for(int i = 0; i < n; i++)
	{
	 	int x;
	 	scanf("%d", &x);
	 	res ^= get(x);
	}
	if(res) puts("Alice");
	else puts("Bob");
}
 
int main()
{
 	precalc();
 	int t;
 	scanf("%d", &t);
 	for(int i = 0; i < t; i++) solve();
}

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

int main() {
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n;
    vector<int> a(n);
    for (auto& x : a) cin >> x;
    vector<int> p(n + 1);
    for (int i = 0; i < n; ++i) p[i + 1] = p[i] + a[i];
    map<int, int> cnt;
    long long ans = 0;
    for (int len = 0; len <= n; ++len) {
      for (int i = 0; i <= n - len; ++i) {
        int s = p[i] + p[i + len];
        ans += len;
        ans -= 2 * cnt[s];
        ans -= (s % 2 == 1 || !binary_search(p.begin(), p.end(), s / 2));
        cnt[s] += 1;
      }
    }
    cout << ans << '\n';
  }
}

#include <bits/stdc++.h>
 
#define forn(i, n) for (int i = 0; i < int(n); i++)
 
using namespace std;
 
const int D = 10;
const int INF = 1e9;
 
typedef array<array<int, D>, D> mat;
 
mat mul(const mat &a, const mat &b, bool fl){
	mat c;
	forn(i, D) forn(j, D) c[i][j] = INF;
	if (fl){
		forn(i, D) forn(j, D){
			c[j][i] = min(c[j][i], min(a[j][0] + b[0][i], a[j][i] + b[i][i]));
			c[j][0] = min(c[j][0], a[j][i] + b[i][0]);
		}
	}
	else{
		forn(i, D) forn(j, D){
			c[i][j] = min(c[i][j], min(a[i][0] + b[0][j], a[i][i] + b[i][j]));
			c[0][j] = min(c[0][j], a[0][i] + b[i][j]);
		}
	}
	return c;
}
 
struct minqueue{
	vector<pair<mat, mat>> st1, st2;
	
	void push(const mat &a){
		if (!st1.empty())
			st1.push_back({a, mul(st1.back().second, a, true)});
		else
			st1.push_back({a, a});
	}
	
	void pop(){
		if (st2.empty()){
			st2 = st1;
			reverse(st2.begin(), st2.end());
			st1.clear();
			assert(!st2.empty());
			st2[0].second = st2[0].first;
			forn(i, int(st2.size()) - 1)
				st2[i + 1].second = mul(st2[i + 1].first, st2[i].second, false);
		}
		st2.pop_back();
	}
	
	int get(){
		if (st1.empty()) return st2.back().second[0][0];
		if (st2.empty()) return st1.back().second[0][0];
		int ans = INF;
		forn(i, D) ans = min(ans, st2.back().second[0][i] + st1.back().second[i][0]);
		return ans;
	}
};
 
mat tran[D];
 
void init(int d){
	forn(i, D) forn(j, D) tran[d][i][j] = INF;
	for (int i = 1; i <= 9; ++i){
		tran[d][i][i] = i;
		tran[d][i][0] = i;
	}
	tran[d][0][d] = 0;
}
 
int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	for (int i = 1; i <= 9; ++i) init(i);
	int n, k;
	cin >> n >> k;
	string s;
	cin >> s;
	minqueue q;
	forn(i, n){
		q.push(tran[s[i] - '0']);
		if (i - k >= 0) q.pop();
		if (i - k >= -1) cout << q.get() << ' ';
	}
	cout << '\n';
	return 0;
}

#include<bits/stdc++.h>
 
using namespace std;
 
void solve()
{
	string s;
	cin >> s;
	int n = s.size();
	int idx = -1;
	for(int i = 0; i + 1 < n; i++)
		if(s[i] == s[i + 1])
			idx = i;
	if(idx == -1)
	{
		if(s.back() == 'a') cout << (s + "b") << endl;
		else cout << (s + "a") << endl;
	}
	else
	{
		string t = "a";
		if(s[idx] == 'a') t = "b";
		cout << s.substr(0, idx + 1) + t + s.substr(idx + 1) << endl;
	}
}
 
int main()
{
	int t;
	cin >> t;
	for(int i = 0; i < t; i++)
		solve();
}

#include <bits/stdc++.h>
 
using namespace std;
 
int main() {
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n;
    vector<string> s(2);
    for (auto& x : s) cin >> x;
    int ans = 0;
    for (int i = 1; i < n - 1; ++i) {
      bool ok = true;
      ok &= (s[0][i] == '.' && s[1][i] == '.');
      ok &= (s[0][i - 1] != s[1][i - 1]);
      ok &= (s[0][i + 1] != s[1][i + 1]);
      ok &= (s[0][i - 1] == s[0][i + 1]);
      ans += ok;
    }
    cout << ans << '\n';
  }
}

import java.util.LinkedList
 
fun main() {
    repeat(readln().toInt()) {
        val n = readln().toInt()
        val s = readln()
 
        var ans = 0L
        val bracketPositions = LinkedList<Int>()
        for (i in s.indices) {
            var c = s[i]
            if (c == '_') {
                c = if (bracketPositions.isEmpty()) '(' else ')'
            }
            if (c == ')') {
                ans += i - bracketPositions.pollLast()
            }
            else
                bracketPositions.addLast(i)
        }
        println(ans)
    }
}

#include <bits/stdc++.h>
 
using namespace std;
 
const int INF = 1e9;
 
int main() {
  ios::sync_with_stdio(false); cin.tie(0);
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n;
    vector<int> a(n);
    for (auto& x : a) cin >> x;
    vector<vector<int>> g(n);
    for (int i = 1; i < n; ++i) {
        int p;
        cin >> p;
        g[p - 1].push_back(i);
    }
    
    auto check = [&](auto&& self, int v, int x) -> bool {
      if (x > INF) return false;
      bool isLeaf = true;
      if (v) x += max(0, x - a[v]);
      for (auto u : g[v]) {
        isLeaf = false;
        if (!self(self, u, x)) return false;
      }
      return (!isLeaf || x <= a[v]);
    };
    
    int l = 1, r = INF;
    while (l <= r) {
      int mid = (l + r) / 2;
      if (check(check, 0, mid)) {
        l = mid + 1;
      } else {
        r = mid - 1;
      }
    }
    
    cout << a[0] + l - 1 << '\n';
  }
}

#include <bits/stdc++.h>
#include "ext/pb_ds/assoc_container.hpp"
 
#define forn(i, n) for (int i = 0; i < int(n); i++)
 
using namespace __gnu_pbds;
using namespace std;
 
template <typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
 
struct query{
	int i, j;
};
 
int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	int n, m;
	cin >> n >> m;
	vector<int> a(n);
	forn(i, n) cin >> a[i];
	vector<vector<query>> q(n + 1);
	forn(j, m){
		int i, x;
		cin >> i >> x;
		--i;
		q[x].push_back({i, j});
	}
	forn(i, n + 1){
		sort(q[i].begin(), q[i].end(), [](const query &a, const query &b){
			return a.i > b.i;
		});
	}
	vector<int> ord(n);
	iota(ord.begin(), ord.end(), 0);
	sort(ord.begin(), ord.end(), [&](int i, int j){
		return a[i] > a[j];
	});
	
	vector<int> cur(n + 1);
	vector<char> ans(m);
	ordered_set<int> alive(ord.begin(), ord.end());
	for (int lvl = 1; lvl <= n; ++lvl){
		for (int k = 1; k <= n; ++k){
			if (cur[k] >= n) break;
			int x = alive.order_of_key(cur[k]);
			int nxt = x + k - 1 >= int(alive.size()) ? n : *alive.find_by_order(x + k - 1);
			while (!q[k].empty() && q[k].back().i <= nxt){
				ans[q[k].back().j] = (a[q[k].back().i] >= lvl);
				q[k].pop_back();
			}
			cur[k] = nxt + 1;
		}
		while (!ord.empty() && a[ord.back()] == lvl){
			alive.erase(ord.back());
			ord.pop_back();
		}
	}
	
	for (auto x : ans) cout << (x ? "YES" : "NO") << '\n';
	return 0;
}

#include <bits/stdc++.h>
 
#define forn(i, n) for (int i = 0; i < int(n); i++)
 
using namespace std;
 
struct query{
	int i, j;
};
 
int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	int n, m;
	cin >> n >> m;
	vector<int> a(n);
	forn(i, n) cin >> a[i];
	vector<vector<query>> q(n + 1);
	forn(j, m){
		int i, x;
		cin >> i >> x;
		--i;
		q[x].push_back({i, j});
	}
	forn(i, n + 1) sort(q[i].begin(), q[i].end(), [](const query &a, const query &b){
		return a.i > b.i;
	});
	
	int P = min(1000, n + 1);
	
	vector<char> ans(m);
	for (int k = 1; k < P; ++k){
		int cur = 1;
		int cnt = 0;
		forn(i, n){
			bool fl = false;
			if (a[i] >= cur){
				++cnt;
				fl = true;
				if (cnt == k){
					++cur;
					cnt = 0;
				}
			}
			while (!q[k].empty() && q[k].back().i == i){
				ans[q[k].back().j] = fl;
				q[k].pop_back();
			}
		}
	}
	
	vector<int> sum1(n), sum2(n);
	int p2 = ceil(sqrt(n + 2));
	
	auto add = [&](int i){
		int bl = i / p2;
		for (int j = bl + 1; j * p2 < n; ++j)
			++sum1[j];
		for (int j = i; j < (bl + 1) * p2 && j < n; ++j)
			++sum2[j];
	};
	
	int mx = n / P + 5;
	vector<vector<int>> pos(mx);
	forn(i, n){
		if (a[i] < mx)
			pos[a[i]].push_back(i);
		else
			add(i);
	}
	for (auto &it : pos) reverse(it.begin(), it.end());
	
	for (int k = P; k <= n; ++k){
		while (true){
			int mn = n;
			int who = -1;
			forn(lvl, mx) if (!pos[lvl].empty()){
				int i = pos[lvl].back();
				if (mn < i) continue;
				int cnt = sum1[i / p2] + sum2[i];
				if (a[i] >= cnt / k + 1){
					mn = i;
					who = lvl;
				}
			}
			if (who == -1) break;
			add(mn);
			pos[who].pop_back();
		}
		for (auto it : q[k]){
			int lvl = a[it.i];
			ans[it.j] = (lvl >= mx || pos[lvl].empty() || pos[lvl].back() > it.i);
		}
	}
	
	for (auto x : ans) cout << (x ? "YES" : "NO") << '\n';
	return 0;
}

#include<bits/stdc++.h>
 
using namespace std;
 
const int MOD = 998244353;
 
int add(int x, int y)
{
 	x += y;
 	while(x >= MOD) x -= MOD;
 	while(x < 0) x += MOD;
 	return x;
}
 
int mul(int x, int y)
{
 	return (x * 1ll * y) % MOD;
}
 
int main()
{
 	int n, x, m;
 	cin >> n >> x >> m;
 	vector<int> fib = {0, 1};
 	for(int i = 2; i <= 30; i++)
 		fib.push_back(fib[i - 1] + fib[i - 2]);
 
 
 	int max_sum = fib[x] * n;
 	vector<vector<int>> dp(max_sum + 1, vector<int>(n + 1));
 	dp[0][0] = 1;
 	for(int i = 1; i <= x; i++)
 		for(int j = 0; j < max_sum; j++)
 			for(int k = 0; k < n; k++)
 			{
 			 	if(j + fib[i] <= max_sum)
 			 		dp[j + fib[i]][k + 1] = add(dp[j + fib[i]][k + 1], dp[j][k]);
 			}
	
	vector<int> cost(max_sum + 1, 1e9);
	cost[0] = 0;
	for(int j = 1; j <= max_sum; j++)
		for(int i = 1; i <= 30; i++)
			if(j >= fib[i])
				cost[j] = min(cost[j], cost[j - fib[i]] + 1);
 
	int ans = 0;
	for(int i = 0; i <= max_sum; i++)
		if(cost[i] == m)
			ans = add(ans, dp[i][n]);
	cout << ans << endl;
}

for _ in range(int(input())):
	x, y = map(int, input().split())
	print("YES" if y >= -1 else "NO")

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

int main() {
  int t;
  cin >> t;
  while (t--) {
    string a, b;
    cin >> a >> b;
    int n = a.size(), m = b.size();
    int ans = n + m;
    for (int i = 0; i < m; ++i) {
      int j = i;
      for (auto c : a) {
        if (j < m && c == b[j]) ++j;
      }
      ans = min(ans, n + m - (j - i));
    }
    cout << ans << '\n';
  }
}

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

int main() {
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n;
    vector<int> a(n), b(n);
    for (auto& x : a) cin >> x;
    for (auto& x : b) cin >> x;
    int x = 0, y = 0, neg = 0, pos = 0;
    for (int i = 0; i < n; ++i) {
      if (a[i] > b[i]) {
        x += a[i];
      } else if (a[i] < b[i]) {
        y += b[i];
      } else {
        neg += (a[i] < 0);
        pos += (a[i] > 0);
      }
    }
    int ans = -1e9;
    for (int i = -neg; i <= pos; ++i)
      ans = max(ans, min(x + i, y + (pos - neg - i)));
    cout << ans << '\n';
  }
}

fun main() {
    val (n, m) = readln().split(" ").map { it.toInt() }
    val a = readln().split(" ").map { it.toInt() }
    val b = readln().split(" ").map { it.toInt() }
    val c = readln().split(" ").map { it.toInt() }

    val mx = a.maxOrNull()!! + 1

    val best = IntArray(mx) { 1e9.toInt() }
    val calc = IntArray(mx) { 0 }

    for (i in a.indices)
        best[a[i]] = minOf(best[a[i]], a[i] - b[i])
    for (v in 1 until mx)
        best[v] = minOf(best[v], best[v - 1])

    for (v in 1 until mx)
        if (v >= best[v])
            calc[v] = 2 + calc[v - best[v]]

    var ans = 0L
    for (v in c) {
        var cur = v
        if (cur >= mx) {
            val k = (cur - mx + 1 + best[mx - 1]) / best[mx - 1]
            ans += 2L * k
            cur -= k * best[mx - 1]
        }
        ans += calc[cur]
    }
    println(ans)
}

#include<bits/stdc++.h>

using namespace std;

const int MOD = 998244353;

int add(int x, int y)
{
 	x += y;
 	while(x >= MOD) x -= MOD;
 	while(x < 0) x += MOD;
 	return x;
}

int mul(int x, int y)
{
 	return (x * 1ll * y) % MOD;
}

int main()
{
	int n;
	cin >> n;
	int k;
	cin >> k;
	vector<vector<int>> dp(n + 1, vector<int>(k + 1));
	dp[0][0] = 1;
	vector<int> sum(k + 1);
	sum[0] = 1;
	for(int i = 0; i < n; i++)
	{
		for(int j = 0; j <= k; j++)
		{
			int& d = dp[i + 1][min(j + 1, k)];
		 	d = add(d, sum[j]);
		 	if(i >= 2 && i != n - 1)
		 		d = add(d, -dp[i - 1][j]); 
		}
		for(int j = 0; j <= k; j++)
			sum[j] = add(sum[j], dp[i + 1][j]);
	}
	cout << dp[n][k] << endl;
}

#include <bits/stdc++.h>

#define forn(i, n) for (int i = 0; i < int(n); i++)

using namespace std;

struct edge{
	int v, u;
};

vector<vector<int>> g, tg;
vector<int> ord;
vector<char> used;
vector<int> clr;

void ts(int v){
	used[v] = true;
	for (int u : g[v]) if (!used[u])
		ts(u);
	ord.push_back(v);
}

void dfs(int v, int k){
	clr[v] = k;
	for (int u : tg[v]) if (clr[u] == -1)
		dfs(u, k);
}

vector<long long> rk, p;
long long sum;
vector<long long*> where;
vector<long long> val;

long long cost(int x){
	return x == 1 ? 0ll : x * 1ll * x;
}

int getp(int a){
	return a == p[a] ? a : getp(p[a]);
}

void unite(int a, int b){
	a = getp(a), b = getp(b);
	if (a == b) return;
	if (clr[a] != clr[b]) return;
	if (rk[a] < rk[b]) swap(a, b);
	where.push_back(&sum);
	val.push_back(sum);
	sum -= cost(rk[a]);
	sum -= cost(rk[b]);
	sum += cost(rk[a] + rk[b]);
	where.push_back(&rk[a]);
	val.push_back(rk[a]);
	rk[a] += rk[b];
	where.push_back(&p[b]);
	val.push_back(p[b]);
	p[b] = a;
}

vector<edge> e;
vector<long long> ans;

void calc(int l, int r, const vector<int> &cur){
	if (l == r - 1){
		ans.push_back(sum);
		return;
	}
	int m = (l + r) / 2;
	for (int i : cur) if (i < m){
		int v = getp(e[i].v), u = getp(e[i].u);
		for (int w : {v, u}) if (used[w]){
			g[w].clear();
			tg[w].clear();
			clr[w] = -1;
			used[w] = false;
		}
		g[v].push_back(u);
		tg[u].push_back(v);
	}
	ord.clear();
	for (int i : cur) if (i < m){
		for (int v : {getp(e[i].v), getp(e[i].u)}) if (!used[v]){
			ts(v);
		}
	}
	reverse(ord.begin(), ord.end());
	int k = 0;
	for (int v : ord) if (clr[v] == -1){
		dfs(v, k);
		++k;
	}
	int tim = val.size();
	for (int i : cur) if (i < m) unite(e[i].v, e[i].u);
	vector<int> tol, tor;
	for (int i : cur){
		if (i >= m)
			tor.push_back(i);
		else if (getp(e[i].v) == getp(e[i].u))
			tol.push_back(i);
		else
			tor.push_back(i);
	}
	calc(m, r, tor);
	while (int(val.size()) > tim){
		*where.back() = val.back();
		where.pop_back();
		val.pop_back();
	}
	calc(l, m, tol);
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	int n, m, q;
	cin >> n >> m >> q;
	e.resize(q);
	forn(i, q){
		int x, y;
		char c;
		cin >> x >> y >> c;
		--x, --y;
		if (c == 'R')
			e[i] = {y + n, x};
		else
			e[i] = {x, y + n};
	}
	rk.resize(n + m, 1);
	p.resize(n + m);
	iota(p.begin(), p.end(), 0);
	used.resize(n + m, 0);
	clr.resize(n + m, -1);
	g.resize(n + m);
	tg.resize(n + m);
	vector<int> cur(q);
	iota(cur.begin(), cur.end(), 0);
	calc(0, q + 1, cur);
	ans.pop_back();
	reverse(ans.begin(), ans.end());
	for (long long x : ans) cout << x << '\n';
	return 0;
}

for _ in range(int(input())):
	n = int(input())
	s = input()
	print("YES" if list(s) == sorted(s) else "NO")

#include <bits/stdc++.h>
 
using namespace std;
 
using li = long long;
 
int main() {
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n;
    vector<li> a(n), b(n + 1);
    for (auto& x : a) cin >> x;
    for (auto& x : b) cin >> x;
    li sum = 0, ext = 1e18;
    for (int i = 0; i < n; ++i) {
      sum += abs(a[i] - b[i]);
      ext = min(ext, abs(a[i] - b[n]));
      ext = min(ext, abs(b[i] - b[n]));
      if (min(a[i], b[i]) <= b[n] && b[n] <= max(a[i], b[i]))
        ext = 0;
    }
    cout << sum + ext + 1 << '\n';
  }
}

for _ in range(int(input())):
    n, m = map(int, input().split())
    bounds = [n, m]
    a = []
    a.append(list(map(int, input().split())))
    a.append(list(map(int, input().split())))
    
    bad = -1
    badType = -1
    cur = [0, 0]
    ans = 0
    types = [0 for i in range(n + m + 1)]
    for i in range(n + m):
        curType = 0
        if a[0][i] < a[1][i]:
            curType = 1
        if cur[curType] == bounds[curType]:
            curType = 1 - curType
            if bad == -1:
                bad = i
                badType = 1 - curType
        types[i] = curType
        ans += a[types[i]][i]
        cur[types[i]] += 1
        
    res = []
    for i in range(n + m):
        val = ans - a[types[i]][i]
        if bad != -1 and i < bad and types[i] == badType:
            val = val + a[badType][bad] - a[1 - badType][bad] + a[1 - badType][n + m]
        else:
            val = val + a[types[i]][n + m]
        res.append(val)
    res.append(ans)
    print(*res)

#include <bits/stdc++.h>
 
using namespace std;
 
int main() {
  int t;
  cin >> t;
  while (t--) {
    string s;
    cin >> s;
    map<int, int> cnt;
    int b = 0;
    ++cnt[b];
    long long ans = 0;
    for (auto& c : s) {
      b += (c == '(' ? +1 : -1);
      ans += cnt[b];
      ++cnt[b];
      while (cnt.begin()->first * 2 < b)
        cnt.erase(cnt.begin());
    }
    cout << ans << '\n';
  }
}

#include<bits/stdc++.h>
 
using namespace std;
 
const int N = 300043;
const int MOD = 998244353;
 
int add(int x, int y)
{
	x += y;
	while(x >= MOD) x -= MOD;
	while(x < 0) x += MOD;
	return x;
}
 
int mul(int x, int y)
{
	return (x * 1ll * y) % MOD;
}
 
int nxt[N], prv[N];
bool exists[N];
 
int main()
{
	int n, q;
	scanf("%d %d", &n, &q);
	for(int i = 1; i <= n; i++) nxt[i] = prv[i] = -1;
	exists[n] = true;
	vector<int> l(q), r(q);
	for(int i = 0; i < q; i++) scanf("%d", &l[i]);
	for(int i = 0; i < q; i++) scanf("%d", &r[i]);
	for(int i = 0; i < q; i++)
	{
		int L = l[i], R = r[i];
		if(exists[L])
		{
			exists[R] = true;
			nxt[R] = nxt[L];
			if(nxt[R] != -1) prv[nxt[R]] = R;
			prv[R] = L;
			nxt[L] = R;
		}
		else
		{
			exists[L] = true;
			prv[L] = prv[R];
			if(prv[L] != -1) nxt[prv[L]] = L;
			nxt[L] = R;
			prv[R] = L;
		}
	}
	vector<int> seq;
	int start = -1;
	for(int i = 1; i <= n; i++)
		if(prv[i] == -1 && exists[i])
			start = i;
	seq.push_back(start);
	while(nxt[start] != -1)
	{
		start = nxt[start];
		seq.push_back(start);
	}
	vector<int> cnt_segments(n + 1);
	cnt_segments[seq[0]]++;
	cnt_segments[seq[q]]++;
	for(int i = 0; i < q; i++)
		cnt_segments[max(seq[i], seq[i + 1])]++;
	int ans = 1;
	int places = 0;
	for(int i = n; i >= 1; i--)
	{
		if(exists[i])
			places += cnt_segments[i];
		else
		{
			ans = mul(ans, places);
			places++;
		}
	}
	printf("%d\n", ans);
}

#include <bits/stdc++.h>
 
#define forn(i, n) for (int i = 0; i < int(n); i++)
 
using namespace std;
 
vector<int> h;
vector<vector<int>> g;
 
void dfs(int v, int p = -1){
	for (int u : g[v]) if (u != p){
		dfs(u, v);
		h[v] = max(h[v], h[u] + 1);
	}
}
 
int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	int t;
	cin >> t;
	while (t--){
		int n;
		cin >> n;
		g.assign(n, {});
		forn(i, n - 1){
			int v, u;
			cin >> v >> u;
			--v, --u;
			g[v].push_back(u);
			g[u].push_back(v);
		}
		h.assign(n, 0);
		dfs(0);
		set<pair<int, int>> cur;
		forn(i, n) cur.insert({h[i], i});
		vector<int> ans;
		int tmp = n;
		while (!cur.empty()){
			int v = cur.rbegin()->second;
			while (v != -1){
				--tmp;
				cur.erase({h[v], v});
				int pv = -1;
				for (int u : g[v]) if (h[u] == h[v] - 1){
					pv = u;
					break;
				}
				v = pv;
			}
			ans.push_back(tmp);
		}
		for (int i = 0; i < int(ans.size()); i += 2){
			cout << ans[i] << ' ';
		}
		for (int i = (int(ans.size()) + 1) / 2; i < n - 1; ++i){
			cout << 0 << ' ';
		}
		cout << '\n';
	}
	return 0;
}

for _ in range(int(input())):
    n = int(input())
    p = [int(x) - 1 for x in input().split()]
    ans = 3
    for i in range(n):
        if p[p[i]] == i:
            ans = 2
    print(ans)

fun main() {
    repeat(readln().toInt()) {
        val s = readln().map { it.code - '0'.code }
        val zeroes = s.count { it == 0 }
        val cnt = intArrayOf(0, 0)
        var ans = 0L
        for (c in s) {
            cnt[c]++
            if (c == 0)
                ans += if (cnt[1] > 0) 1 else 0
            else
                ans += (zeroes - cnt[0])
        }
        println(ans)
    }
}

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

using li = long long;
const li INF = 1e18;

int main() {
  int t;
  cin >> t;
  while (t--) {
    int n, k;
    cin >> n >> k;
    vector<li> a(n);
    for (auto& x : a) cin >> x;
    vector<vector<li>> dp(n + 1, vector<li>(k + 1, INF));
    dp[0][0] = 0;
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j <= k; ++j) {
        li mn = INF;
        for (int d = 0; j + d <= k && i + d < n; ++d) {
          mn = min(mn, a[i + d]);
          dp[i + d + 1][j + d] = min(dp[i + d + 1][j + d], dp[i][j] + (d + 1) * mn);
        }
      }
    }
    cout << *min_element(dp[n].begin(), dp[n].end()) << '\n';
  }
}

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

#define sz(a) int((a).size())
using li = long long;

int main() {
  int t;
  cin >> t;
  while (t--) {
    int n, k;
    cin >> n >> k;
    vector<int> a(n), b(n);
    for (auto& x : a) cin >> x;
    for (auto& x : b) cin >> x;
    vector<int> ord(n);
    iota(ord.begin(), ord.end(), 0);
    sort(ord.begin(), ord.end(), [&](int i, int j) {
      return b[i] > b[j];
    });
    li f = 0, p = 0;
    for (int i : ord) p += max(0, b[i] - a[i]);
    li ans = 0;
    multiset<int> s;
    if (sz(s) == k) ans = max(ans, p - f);
    for (int i : ord) {
      p -= max(0, b[i] - a[i]);
      s.insert(a[i]);
      f += a[i];
      if (sz(s) > k) {
        f -= *s.rbegin();
        s.erase(--s.end());
      }
      if (sz(s) == k) ans = max(ans, p - f);
    }
    cout << ans << '\n';
  }
}

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

#define sz(a) int((a).size())

vector<int> t, p;

void push(int v) {
  if (v * 2 + 2 >= sz(t)) return;
  t[v * 2 + 1] += p[v]; p[v * 2 + 1] += p[v];
  t[v * 2 + 2] += p[v]; p[v * 2 + 2] += p[v];
  p[v] = 0;
}

void upd(int v, int l, int r, int L, int R, int x) {
  if (L >= R) return;
  if (l == L && r == R) {
    t[v] += x; p[v] += x;
    return;
  }
  int m = (l + r) / 2;
  push(v);
  upd(v * 2 + 1, l, m, l, min(m, R), x);
  upd(v * 2 + 2, m, r, max(m, L), R, x);
  t[v] = min(t[v * 2 + 1], t[v * 2 + 2]);
}

int get(int v, int l, int r, int L, int R) {
  if (L >= R) return 1e9;
  if (l == L && r == R) return t[v];
  int m = (l + r) / 2;
  push(v);
  return min(
    get(v * 2 + 1, l, m, l, min(m, R)),
    get(v * 2 + 2, m, r, max(m, L), R)
  );
}

void solve() {
  int n;
  cin >> n;
  vector<int> a(n);
  for (auto& x : a) cin >> x, --x;
  t = p = vector<int>(4 * n);
  vector<vector<int>> pos(n);
  int ans = 0, st = 0;
  for (int i = 0; i < n; ++i) {
    int x = a[i];
    pos[x].push_back(i);
    int k = sz(pos[x]);
    if (k > 0) upd(0, 0, n, st, pos[x][k - 1] + 1, +1);
    if (k > 1) upd(0, 0, n, st, pos[x][k - 2] + 1, -2);
    if (k > 2) upd(0, 0, n, st, pos[x][k - 3] + 1, +1);
    if (get(0, 0, n, st, i + 1) == 0) {
      ans += 1;
      st = i + 1;
    }
  }
  cout << ans << '\n';
}

int main() {
  int t;
  cin >> t;
  while (t--) solve();
}

#include<bits/stdc++.h>

using namespace std;

mt19937_64 rnd(12341234);

int n, k;
vector<int> deck;
vector<int> dp;
vector<vector<bool>> odd;
vector<bool> full_odd;
vector<long long> val;
vector<long long> hs;      

bool bad(const vector<bool>& v)
{
    for(int i = 0; i < k; i++)
        if(!v[i])
            return false;
    return true;
}

vector<bool> inv(const vector<bool>& v)
{
    vector<bool> res(k);
    for(int i = 0; i < k; i++)
        res[i] = !v[i];
    return res;
}

vector<bool> get_suffix(int l)
{
    vector<bool> v(k);                     
    for(int i = l; i < n; i++) v[deck[i]] = !v[deck[i]];
    return v;
}

int get_next(long long cur, int x)
{
    for(int i = x; i <= n; i += 2)
        if(hs[i] == cur)
            return i;
    return -1;
}                

int main()
{
    cin >> n >> k;
    deck.resize(n);
    for(int i = 0; i < n; i++) cin >> deck[i];
    for(int i = 0; i < n; i++) --deck[i];
    val.resize(k);
    for(int i = 0; i < k; i++)
        while(val[i] == 0)
            val[i] = rnd();

    int max_score = 0;
    dp.resize(n + 1);
    full_odd.resize(k);
    odd.resize(n + 1, vector<bool>(k));
    hs.resize(n + 1);
    long long cur_hash = 0;
    for(int i = 0; i < n; i++)
    {
        cur_hash ^= val[deck[i]];
        if(full_odd[deck[i]]) max_score++;
        full_odd[deck[i]] = !full_odd[deck[i]];
        odd[i + 1] = full_odd;
        hs[i + 1] = cur_hash;
    }   

    for(int i = k; i <= n; i++)
        dp[i] = 1e9;                          
    long long start = 0ll;
    for(int i = 0; i < k; i++) start ^= val[i];
    int pos = get_next(start, k);
    if(pos == -1)
    {
        cout << max_score << endl;  
    }
    else
    {
        dp[pos] = 0;
        int ans = 1e9;
        for(int p = k; p <= n; p += 2)
        {
            if(dp[p] > 1e8) continue;   
            vector<bool> suff = get_suffix(p);
            vector<int> o, e;
            for(int j = 0; j < k; j++)
                if(suff[j])
                    e.push_back(j);
                else
                    o.push_back(j);
            int es = e.size();
            int os = o.size();
            bool flag = true;
            for(int i = 0; i < os && flag; i++)
                for(int j = 0; j < i && flag; j++)
                {
                    int x = o[i];
                    int y = o[j];
                    int add = 0;         
                    long long h = hs[p] ^ val[x] ^ val[y];
                    int pos = get_next(h, p);
                    if(pos == -1)                  
                    {
                        flag = false;
                        ans = min(ans, dp[p] + add);
                    }
                    else
                        dp[pos] = min(dp[pos], dp[p] + add);
                }

            for(int i = 0; i < os && flag; i++)
                for(int j = 0; j < es && flag; j++)
                {
                    int x = o[i];
                    int y = e[j];
                    int add = 1;         
                    long long h = hs[p] ^ val[x] ^ val[y];
                    int pos = get_next(h, p);    
                    if(pos == -1)
                    {
                        flag = false;
                        ans = min(ans, dp[p] + add);
                    }
                    else
                        dp[pos] = min(dp[pos], dp[p] + add);
                }

            for(int i = 0; i < es && flag; i++)
                for(int j = 0; j < i && flag; j++)
                {
                    int x = e[i];
                    int y = e[j];
                    int add = 2;                             
                    long long h = hs[p] ^ val[x] ^ val[y];
                    int pos = get_next(h, p);
                    if(pos == -1)
                    {
                        flag = false;
                        ans = min(ans, dp[p] + add);
                    }
                    else
                        dp[pos] = min(dp[pos], dp[p] + add);
                }
        }
        cout << max_score - ans << endl;
    }       
}

t = int(input())
for i in range(t):
    n, m, k = map(int, input().split())
    max_color = (n + m - 1) / m
    if max_color + k >= n:
        print('NO')
    else:
        print('YES')

for _ in range(int(input())):
    n = int(input())
    a = list(map(int, input().split()))
    lst = -1
    ans = n
    for i in range(n):
        if a[i] != a[0]:
            ans = min(ans, i - lst - 1)
            lst = i
    ans = min(ans, n - lst - 1)
    if ans == n:
        print(-1)
    else:
        print(ans)

#include <bits/stdc++.h>
 
using namespace std;
 
int main() {
  int t;
  cin >> t;
  while (t--) {
    string x, y;
    cin >> x >> y;
    int n = x.size();
    bool f = false;
    for (int i = 0; i < n; ++i) {
      if ((x[i] > y[i]) == f) swap(x[i], y[i]);
      f |= (x[i] != y[i]);
    }
    cout << x << '\n' << y << '\n';
  }
}

#include <bits/stdc++.h>
 
using namespace std;
 
const int MOD = 998244353;
 
int add(int x, int y) {
  x += y;
  if (x >= MOD) x -= MOD;
  return x;
} 
 
int mul(int x, int y) {
  return x * 1LL * y % MOD;
}
 
int main() {
  int n;
  cin >> n;
  vector<int> a(n);
  for (int i = 0; i < n; ++i) cin >> a[i];
  int s = accumulate(a.begin(), a.end(), 0);
  vector<int> dp(s + 1);
  dp[0] = 1;
  for (int i = 0; i < n; ++i)
    for (int j = s - a[i]; j >= 0; --j) 
      dp[j + a[i]] = add(dp[j + a[i]], dp[j]);
  int ans = 0;
  for (int j = 0; j <= s; ++j) 
    ans = add(ans, mul((j + 1) / 2, dp[j]));
  for (int i = 0; i < n; ++i)
    for (int j = 0; j < a[i]; ++j) 
      ans = add(ans, mul(a[i] - (a[i] + j + 1) / 2, dp[j]));
  cout << ans << '\n';
}

#include <bits/stdc++.h>
 
#define forn(i, n) for (int i = 0; i < int(n); i++)
 
using namespace std;
 
int divup(int a, int b){
    return (a + b - 1) / b;
}
 
int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    int n;
    cin >> n;
    vector<int> a(n);
    forn(i, n) cin >> a[i];
    int mx = *max_element(a.begin(), a.end());
    vector<long long> ans(mx + 1);
    forn(i, n){
        int coef = 0;
        if (i == 0 || a[i] > a[i - 1]) ++coef;
        if (i + 1 < n && a[i] < a[i + 1]) --coef;
        int r = a[i];
        ans[r] += coef;
        while (r > 0){
            int val = divup(a[i], r);
            int l = divup(a[i], val);
            ans[l - 1] += coef * val;
            ans[r] -= coef * val;
            r = l - 1;
        }
    }
    forn(i, mx) ans[i + 1] += ans[i];
    forn(i, mx) cout << ans[i] << ' ';
    cout << '\n';
    return 0;
}

#include <bits/stdc++.h>
 
#define forn(i, n) for (int i = 0; i < int(n); i++)
 
using namespace std;
 
int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    int n;
    cin >> n;
    vector<int> a(n);
    forn(i, n) cin >> a[i];
    int mx = *max_element(a.begin(), a.end());
    vector<long long> pr(mx + 1);
    forn(i, n){
        int coef = 0;
        if (i == 0 || a[i] > a[i - 1]) ++coef;
        if (i + 1 < n && a[i] < a[i + 1]) --coef;
        pr[a[i]] += coef;
    }
    forn(i, mx) pr[i + 1] += pr[i];
    for (int k = 1; k <= mx; ++k){
        long long ans = 0;
        for (int l = 1, val = 1; l <= mx; l += k, ++val)
            ans += val * 1ll * (pr[min(mx, l + k - 1)] - pr[l - 1]);
        cout << ans << ' ';
    }
    cout << '\n';
    return 0;
}

#include<bits/stdc++.h>
 
using namespace std;
 
#define fore(i, l, r) for(int i = int(l); i < int(r); i++)
#define sz(a) int((a).size())
 
typedef long long li;
typedef pair<int, int> pt;
 
template<class A, class B> ostream& operator <<(ostream& out, const pair<A, B> &p) {
    return out << "(" << p.x << ", " << p.y << ")";
}
template<class A> ostream& operator <<(ostream& out, const vector<A> &v) {
    fore(i, 0, sz(v)) {
        if(i) out << " ";
        out << v[i];
    }
    return out;
}
 
const int MOD = int(1e9) + 7;
int add(int a, int b) {
    a += b;
    while (a >= MOD)
        a -= MOD;
    while (a < 0)
        a += MOD;
    return a;
}
void upd(int &ans, int val) {
    ans = add(ans, val);
}
int mul(int a, int b) {
    return int(a * 1ll * b % MOD);
}
int binPow(int a, int k) {
    int ans = 1;
    while (k > 0) {
        if (k & 1)
            ans = mul(ans, a);
        a = mul(a, a);
        k >>= 1;
    }
    return ans;
}
 
const int N = 3055;
int f[N], invf[N];
 
void precalcFact() {
    f[0] = invf[0] = 1;
    fore (i, 1, N) {
        f[i] = mul(f[i - 1], i);
        invf[i] = binPow(f[i], MOD - 2);
    }
}
int C(int n, int k) {
    if (k < 0 || k > n)
        return 0;
    return mul(f[n], mul(invf[k], invf[n - k]));
}
 
int n, c, k;
 
inline bool read() {
    if(!(cin >> n >> c >> k))
        return false;
    return true;
}
 
int d[N][N], sum[N][N];
 
// d[z][l] - number of strings of length l, with z zeroes and blocks of 1-s shorter than mx
void precalcShort(int mx) {
    memset(d, 0, sizeof d);
    d[0][0] = 1;
    fore (z, 0, n) {
        fore (l, 0, n) {
            if (d[z][l] == 0)
                continue;
            upd(d[z + 1][l + 1], +d[z][l]);
            upd(d[z + 1][min(n, l + mx) + 1], -d[z][l]);
        }
        fore (l, 0, n + 1)
            upd(d[z + 1][l + 1], d[z + 1][l]);
    }
        
    memset(sum, 0, sizeof sum);
    fore (z, 0, n + 1) fore (l, 0, n + 1)
        sum[z][l + 1] = add(sum[z][l], d[z][l]);
    
}
 
//[lf, rg)
int getSum(int z, int lf, int rg) {
    if (z < 0 || z > n || lf >= rg)
        return 0;
    return add(sum[z][rg], -sum[z][lf]);
}
 
// cnt[g] is a number of x <= n with gcd(x, n) = g
vector<int> precalcCnt(int n) {
    vector<int> cnt(n + 1, 0);
    fore (x, 1, n + 1)
        cnt[gcd(x, n)]++;
    return cnt;
}
 
int calcFixedPoints(int g) {
    if (c >= g)
        return c + k >= n;
    
    int cntOnes = (c + k) / (n / g);
    int cntZeros = g - cntOnes;
    
    int all = 0;
    fore (ones, 0, cntOnes + 1)
        upd(all, C(g, ones));
    
    int bad = 0;
    fore (pref, 0, c) {
        int minZeros = max(0, cntZeros - 1);
        int minMid = g - c;
        int sufLen = g - pref - 1;
        fore (z, minZeros, sufLen + 1)
            upd(bad, getSum(z, minMid, sufLen + 1));
    }
    return add(all, -bad);
}
 
inline void solve() {
    precalcFact();
    precalcShort(c);
    auto cnt = precalcCnt(n);
    
    int ans = 0;
    fore (g, 1, n + 1) {
        if (n % g != 0)
            continue;
        
        int cntFP = calcFixedPoints(g);
//      cerr << "g = " << g << " += " << cnt[g] << " * " << cntFP << endl;
        upd(ans, mul(cnt[g], cntFP));
    }
    
//  cerr << "ans/n = " << ans << " " << n << endl;
    cout << mul(ans, binPow(n, MOD - 2)) << endl;
}
 
int main() {
#ifdef _DEBUG
    freopen("input.txt", "r", stdin);
    int tt = clock();
#endif
    ios_base::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    cout << fixed << setprecision(15);
    
    if(read()) {
        solve();
        
#ifdef _DEBUG
        cerr << "TIME = " << clock() - tt << endl;
        tt = clock();
#endif
    }
    return 0;
}

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

int main() {
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n;
    if (n % 2 == 1) {
      cout << "NO" << '\n';
      continue;
    }
    cout << "YES" << '\n';
    for (int i = 0; i < n / 2; ++i)
      for (int j = 0; j < 2; ++j)
        cout << "AB"[i & 1];
    cout << '\n';
  }
}

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

int main() {
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n;
    vector<int> a(n);
    for (auto& x : a) cin >> x;
    vector<int> b({a[n - 1]});
    for (int i = n - 2; i >= 0; --i) {
      if (a[i] > b.back()) {
        b.push_back(a[i] % 10);
        b.push_back(a[i] / 10);
      } else {
        b.push_back(a[i]);
      }
    }
    cout << (is_sorted(b.rbegin(), b.rend()) ? "YES" : "NO") << '\n';
  }
}

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

int main() {
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n;
    vector<char> ok1(n / 2), ok2(n / 2);
    for (int i = 0; i < 2; ++i) {
      string s;
      cin >> s;
      for (int j = 0; j < n; ++j) if ((i + j) & 1) {
        ok1[(i + j) / 2] |= (s[j] == '>');
        ok2[(j - i + 1) / 2] |= (s[j] == '>');
      }
    }
    bool ans = true;
    for (int i = 0; i < n / 2; ++i) ans &= ok1[i] && ok2[i];
    cout << (ans ? "YES" : "NO") << '\n';
  }
}

for _ in range(int(input())):
    s = input()
    n = len(s)
    ans = 0
    for d in range(1, n // 2 + 1):
        cnt = 0
        for i in range(n - d):
            cnt += s[i] == s[i + d] or s[i] == '?' or s[i + d] == '?'
            if i - d >= 0:
                cnt -= s[i - d] == s[i] or s[i - d] == '?' or s[i] == '?'
            if i - d >= -1 and cnt == d:
                ans = 2 * d
    print(ans)

#include<bits/stdc++.h>
 
using namespace std;
 
void solve()
{
    int n, k;
    cin >> n >> k;
    vector<int> a(n), c(n);
    for(int i = 0; i < n; i++)
    {
        a[i] = i + 1;
        c[i] = i / k + 1;
    }
    int q = *max_element(c.begin(), c.end());
    for(int i = 1; i <= q; i++)
    {
        int l = find(c.begin(), c.end(), i) - c.begin();
        int r = c.rend() - find(c.rbegin(), c.rend(), i);
        int m = (l + r) / 2;
        reverse(a.begin() + l, a.begin() + m);
        reverse(a.begin() + m, a.begin() + r);
    }
    for(int i = 0; i < n; i++)
        cout << a[i] << " \n"[i == n - 1];
    cout << q << "\n";
    for(int i = 0; i < n; i++)
        cout << c[i] << " \n"[i == n - 1];
}
 
int main()
{
    int t;
    cin >> t;
    for(int i = 0; i < t; i++)
        solve();
}

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

const int MOD = 998244353;

int add(int x, int y) {
  x += y;
  if (x >= MOD) x -= MOD;
  return x;
}

int mul(int x, int y) {
  return x * 1LL * y % MOD;
}

int binpow(int x, int y) {
  int z = 1;
  while (y) {
    if (y & 1) z = mul(z, x);
    x = mul(x, x);
    y >>= 1;
  }
  return z;
}

int main() {
  ios::sync_with_stdio(false); cin.tie(0);
  int n, q;
  cin >> n >> q;
  vector<int> a(n), b(n);
  for (auto& x : a) cin >> x;
  for (auto& x : b) cin >> x;
  vector<int> suma(n + 1), sumb(n + 1);
  for (int i = 0; i < n; ++i) {
    suma[i + 1] = suma[i] + a[i];
    sumb[i + 1] = sumb[i] + b[i];
  }
  int m = sumb[n];
  vector<int> f(m + 1), invf(m + 1);
  f[0] = 1;
  for (int i = 1; i <= m; ++i) f[i] = mul(f[i - 1], i);
  invf[m] = binpow(f[m], MOD - 2);
  for (int i = m; i > 0; --i) invf[i - 1] = mul(invf[i], i);
  vector<int> sumc(m + 2);
  for (int i = 0; i <= m; ++i)
    sumc[i + 1] = add(sumc[i], mul(f[m], mul(invf[i], invf[m - i])));
  int pw2 = binpow(binpow(2, MOD - 2), m);
  while (q--) {
    int l, r;
    cin >> l >> r;
    --l;
    int k = 2 * (suma[r] - suma[l]) - suma[n];
    int cur = sumb[r] - sumb[l];
    int mx = max(0, min(k + cur, m + 1));
    int cnt = sumc[mx];
    cout << mul(cnt, pw2) << ' ';
  }
}

#include<bits/stdc++.h>

using namespace std;

int n, c;
int g[21][21];

const int INF = int(1e9);

int primMST(int vertex_cover_mask)
{
    vector<int> d(n, INF);
    vector<bool> used(n, false);
    d[0] = 0;
    int ans = 0;
    for(int i = 0; i < n; i++)
    {
        int idx = -1;
        for(int j = 0; j < n; j++)
        {
            if(!used[j] && d[j] < INF && (idx == -1 || d[j] < d[idx]))
                idx = j;
        }
        if(idx == -1) return INF;
        used[idx] = true;
        ans += d[idx];
        for(int k = 0; k < n; k++)
        {
            if(used[k]) 
                continue;
            if((vertex_cover_mask & (1 << idx)) == 0 && (vertex_cover_mask & (1 << k)) == 0)
                continue;
            d[k] = min(d[k], g[idx][k]);
        }
    }
    return ans;
}

int main()
{
    cin >> n >> c;
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            cin >> g[i][j];
            if(g[i][j] == 0) g[i][j] = INF;
        }
    }
    int ans = INF;
    for(int mask = 0; mask < (1 << n); mask++)
    {
        int cur = primMST(mask);
        if(cur != INF) ans = min(ans, cur + c * __builtin_popcount(mask));
    }
    cout << ans << endl;
}

t = int(input())
for i in range(t):
    n = int(input())
    a = list(map(int, input().split()))
    l, r = a.index(1), n - a[::-1].index(1) - 1
    c = a.count(1)
    print(r - l - c + 1)

#include <bits/stdc++.h>
 
using namespace std;
 
int main() {
  int t;
  cin >> t;
  while (t--) {
    int n, k;
    cin >> n >> k;
    vector<int> a(n), x(n);
    for (auto& it : a) cin >> it;
    for (auto& it : x) cin >> it;
    vector<long long> s(n + 1);
    for (int i = 0; i < n; ++i) s[abs(x[i])] += a[i];
    bool ok = true;
    long long lft = 0;
    for (int i = 1; i <= n; ++i) {
      lft += k - s[i];
      ok &= (lft >= 0);
    }
    cout << (ok ? "YES" : "NO") << '\n';
  }
}

#include <bits/stdc++.h>
 
using namespace std;
 
const int N = 300043;
 
int t;
int n, m;
int a[N];
long long sum[N];
int cnt1[N];
 
int main() {
    ios_base::sync_with_stdio(false);
    
    cin >> t;
    for (int tc = 0; tc < t; ++tc) {
        cin >> n >> m;
        memset(sum, 0, sizeof(sum[0]) * (n + 5));
        memset(cnt1, 0, sizeof(cnt1[0]) * (n + 5));
        for (int i = 0; i < n; ++i) {
            cin >> a[i];
            sum[i + 1] = sum[i] + a[i];
            cnt1[i + 1] = cnt1[i] + (a[i] == 1);
        }
        
        for (int i = 0; i < m; ++i) {
            int l, r;
            cin >> l >> r;
            --l;
            int cur_cnt1 = cnt1[r] - cnt1[l];
            long long cur_sum = sum[r] - sum[l];
            
            if((r - l) + cur_cnt1 <= cur_sum && r - l > 1)
                cout << "YES\n";
            else
                cout << "NO\n";
        }
    }
    return 0;
}

#include <bits/stdc++.h>
 
using namespace std;
 
int main() {
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n;
    vector<int> a(n);
    for (auto& x : a) cin >> x;
    vector<int> ans(n, n);
    for (int z = 0; z < 2; ++z) {
      vector<long long> s(n + 1);
      for (int i = 0; i < n; ++i) s[i + 1] = s[i] + a[i];
      vector<int> p(n, -1);
      for (int i = 1; i < n; ++i) {
        int j = (z ? n - i - 1 : i);
        int l = 1, r = i;
        while (l <= r) {
          int m = (l + r) / 2;
          if (s[i] - s[i - m] > a[i] && p[i - 1] >= i - m) {
            ans[j] = min(ans[j], m);
            r = m - 1;
          } else {
            l = m + 1;
          }
        }
        if (a[i - 1] > a[i]) ans[j] = 1;
        p[i] = (a[i] == a[i - 1] ? p[i - 1] : i - 1);
      }
      reverse(a.begin(), a.end());
    }
    for (int i = 0; i < n; ++i)
      cout << (ans[i] == n ? -1 : ans[i]) << ' ';
    cout << '\n';
  }
}

#include <bits/stdc++.h>
 
#define forn(i, n) for (int i = 0; i < int(n); i++)
 
using namespace std;
 
int n;
vector<int> a;
vector<vector<int>> g;
 
long long ans;
vector<map<int, int>> cnt;
 
void dfs(int v, int p = -1){
    int bst = -1;
    for (int u : g[v]) if (u != p){
        dfs(u, v);
        if (bst == -1 || cnt[bst].size() < cnt[u].size())
            bst = u;
    }
    for (int u : g[v]) if (u != p && u != bst){
        for (auto it : cnt[u]){
            int x = it.first, y = it.second;
            if (x != a[v]) ans += cnt[bst][x] * 1ll * y;
            cnt[bst][x] += y;
        }
    }
    if (bst != -1) swap(cnt[bst], cnt[v]);
    ans += cnt[v][a[v]];
    cnt[v][a[v]] = 1;
}
 
int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    int t;
    cin >> t;
    while (t--){
        int n;
        cin >> n;
        a.resize(n);
        forn(i, n) cin >> a[i];
        g.assign(n, {});
        forn(_, n - 1){
            int v, u;
            cin >> v >> u;
            --v, --u;
            g[v].push_back(u);
            g[u].push_back(v);
        }
        ans = 0;
        cnt.assign(n, {});
        dfs(0);
        cout << ans << '\n';
    }
    return 0;
}

#include<bits/stdc++.h>
 
using namespace std;
 
#define fore(i, l, r) for(int i = int(l); i < int(r); i++)
#define sz(a) int((a).size())
#define all(a) (a).begin(), (a).end()
 
typedef long long li;
typedef pair<int, int> pt;
 
const int INF = int(1e9);
const int MOD = int(1e9) + 7;
 
int add(int a, int b) {
    a += b;
    if (a >= MOD)
        a -= MOD;
    return a;
}
int mul(int a, int b) {
    return int(a * 1ll * b % MOD);
}
 
namespace SuffixArray {
    string s;
    vector< array<int, 2> > classes;
    
    vector<int> build(const string &bs) {
        s = bs;
        s += '$';
        
        vector<int> c(all(s)), ord(sz(s));
        iota(all(ord), 0);
        classes.resize(sz(s));
 
        for (int len = 1; len < 2 * sz(s); len <<= 1) {
            int half = len >> 1;
            fore (i, 0, sz(s))
                classes[i] = {c[i], c[(i + half) % sz(s)]};
            
            sort(all(ord), [&](int i, int j) {
                return classes[i] < classes[j];
            });
            c[ord[0]] = 0;
            fore (i, 1, sz(ord))
                c[ord[i]] = c[ord[i - 1]] + (classes[ord[i - 1]] != classes[ord[i]]);
        }
        
        c.pop_back();
        for (int &cc : c)
            cc--;
        return c;
    }
};
 
int n, k;
string s;
 
inline bool read() {
    if(!(cin >> n >> k))
        return false;
    cin >> s;
    return true;
}
 
string calcZero(string s) {
    int rem = k;
    int pos = 0;
    for (int i = sz(s) - 1; rem > 0 && i >= 0; i--) {
        if (s[i] == '1')
            continue;
        
        while (pos < sz(s) && s[pos] == '0')
            pos++;
        if (pos >= i)
            break;
        
        swap(s[pos], s[i]);
        rem--;
    }
    return s.substr(s.find('1'));
}
 
string calcOne(string s) {
    reverse(all(s));
    
    auto c = SuffixArray::build(s);
    int cntOnes = count(all(s), '1');
    
    array<int, 3> mn = { 2 * sz(s), INF, -1 };
        
    int u = 0, curOnes = 0;
    fore (i, 0, n) {
        while (u < sz(s) && (u - i < cntOnes || cntOnes - curOnes > k - 1)) {
            curOnes += s[u] == '1';
            u++;
        }
        if (u - i < cntOnes || cntOnes - curOnes > k - 1)
            break;
        
        array<int, 3> curAns = { u - i, c[i], i };
        mn = min(mn, curAns);
        
        curOnes -= s[i] == '1';
    }
    assert(mn[2] >= 0);
    
    string res = s.substr(mn[2], mn[0]);
    int toAdd = cntOnes - count(all(res), '1');
    for (int i = sz(res) - 1; toAdd > 0 && i >= 0; i--) {
        if (res[i] == '0') {
            res[i] = '1';
            toAdd--;
        }
    }
    return res;
}
 
inline void solve() {
    auto s1 = calcZero(s);
    auto s2 = calcOne(s);
 
    if (sz(s1) > sz(s2) || (sz(s1) == sz(s2) && s1 > s2))
        swap(s1, s2);
    
    int res = 0;
    for (char c : s1)
        res = add(mul(res, 2), c - '0');
    cout << res << endl;
}
 
int main() {
#ifdef _DEBUG
    freopen("input.txt", "r", stdin);
    int tt = clock();
#endif
    ios_base::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    cout << fixed << setprecision(15);
    
    if(read()) {
        solve();
        
#ifdef _DEBUG
        cerr << "TIME = " << clock() - tt << endl;
        tt = clock();
#endif
    }
    return 0;
}

for _ in range(int(input())):
	n = int(input())
	a = input()
	b = input()
	c = input()
	print("YES" if any([a[i] != c[i] and b[i] != c[i] for i in range(n)]) else "NO")

#include <bits/stdc++.h>
 
using namespace std;
 
int t;
 
int main() {
    cin >> t;
    for (int tc = 0; tc < t; ++tc) {
        int n;
        cin >> n;
        map<int, int> numOfLens;
        for (int i = 0; i < n; ++i){
            int x;
            cin >> x;
            ++numOfLens[x];
        }
        
        long long res = 0;
        int sum = 0;
        for (auto it : numOfLens) {
            long long cnt = it.second;
            if(cnt >= 3)
                res += cnt * (cnt - 1) * (cnt - 2) / 6;
            if(cnt >= 2)
                res += cnt * (cnt - 1) / 2 * sum;
            sum += cnt;
        }
        
        cout << res << endl;
    }
    return 0;
}

#include <bits/stdc++.h>
 
using namespace std;
 
const int N = 200'000;
const int INF = 1'000'000'009;
int t;
 
char type(const vector <int>& a, int id) {
    int distL = (id == 0? INF : a[id] - a[id - 1]);
    int distR = (id + 1 == a.size()? INF : a[id + 1] - a[id]);
    if(distL < distR) return 'L';
    if(distL > distR) return 'R';
    assert(false);
}
 
int main() {
    ios::sync_with_stdio(false);
    cin >> t;
    for (int tc = 0; tc < t; ++tc) {
        int n;
        cin >> n;
        vector <int> a(n);
        for (int i = 0; i < n; ++i)
            cin >> a[i];
            
        vector <int> l(n), r(n);
        for (int i = 1; i < n; ++i)
            r[i] = r[i - 1] + (type(a, i - 1) == 'R'? 1 : a[i] - a[i - 1]);
        for (int i = n - 2; i >= 0; --i)
            l[i] = l[i + 1] + (type(a, i + 1) == 'L'? 1 : a[i + 1] - a[i]);
        
        int m;
        cin >> m;
        for (int i = 0; i < m; ++i) {
            int x, y;
            cin >> x >> y;
            --x, --y;
            if (x < y) 
                cout << r[y] - r[x] << endl;
            else
                cout << l[y] - l[x] << endl;
        }
    }
    return 0;
}

#include <bits/stdc++.h>
 
using namespace std;
 
int main() {
  ios::sync_with_stdio(false); cin.tie(0);
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n;
    vector<int> a(n + 2), d(n + 2, INT_MAX);
    for (int i = 1; i <= n; ++i) cin >> a[i];
    for (int i = 1; i <= n; ++i) cin >> d[i];
    set<int> lft, cur;
    for (int i = 0; i < n + 2; ++i) {
      lft.insert(i);
      cur.insert(i);
    }
    for (int z = 0; z < n; ++z) {
      set<int> del, ncur;
      for (int i : cur) {
        auto it = lft.find(i);
        if (it == lft.end()) continue;
        int prv = *prev(it);
        int nxt = *next(it);
        if (a[prv] + a[nxt] > d[i]) {
          del.insert(i);
          ncur.insert(prv);
          ncur.insert(nxt);
        }
      }
      cout << del.size() << ' ';
      for (auto it : del) lft.erase(it);
      cur = ncur;
    }
    cout << '\n';
  }
}

#include <bits/stdc++.h>
 
using namespace std;
 
vector<int> f(long long x) {
  vector<int> res;
  if (x == 2) {
  	res.push_back(0);
  } else if (x & 1) {
    res = f(x - 1);
    res.push_back(*min_element(res.begin(), res.end()) - 1);
  } else {
    res = f(x / 2);
    res.push_back(*max_element(res.begin(), res.end()) + 1);
  }
  return res;
}
 
int main() {
  int t;
  cin >> t;
  while (t--) {
    long long x;
    cin >> x;
    auto ans = f(x);
    cout << ans.size() << '\n';
    for (int i : ans) cout << i << ' ';
    cout << '\n';
  }
}

#include <bits/stdc++.h>
 
using namespace std;
 
const int N = 111;
 
int n, k;
int a[N];
int nxtx[N][N], prvx[N][N];
int nxtnx[N][N], prvnx[N][N];
int dp1[N][N][N], dp2[N][N][N];
 
int calc2(int, int, int);
 
int calc1(int l, int r, int x) {
  l = nxtnx[l][x], r = prvnx[r][x];
  if (l > r) return 0;
  if (dp1[l][r][x] != -1) return dp1[l][r][x];
  dp1[l][r][x] = calc2(l, r, x) + 1;
  for (int i = l; i < r; ++i) dp1[l][r][x] = min(dp1[l][r][x], calc1(l, i, x) + calc1(i + 1, r, x));
  return dp1[l][r][x];
}
 
int calc2(int l, int r, int x) {
  l = nxtx[l][x], r = prvx[r][x];
  if (l > r) return 0;
  if (dp2[l][r][x] != -1) return dp2[l][r][x];
  dp2[l][r][x] = n;
  for (int i = l; i < r; ++i) dp2[l][r][x] = min(dp2[l][r][x], calc2(l, i, x) + calc2(i + 1, r, x));
  for (int y = 0; y < k; ++y) if (x != y) dp2[l][r][x] = min(dp2[l][r][x], calc1(l, r, y)); 
  return dp2[l][r][x];
}
 
void solve() {
  cin >> n >> k;
  for (int i = 0; i < n; ++i) cin >> a[i], --a[i];
  for (int x = 0; x < k; ++x) prvx[0][x] = prvnx[0][x] = -1;
  for (int i = 0; i < n; ++i) {
    prvx[i][a[i]] = i;
    for (int x = 0; x < k; ++x) prvx[i + 1][x] = prvx[i][x];
    for (int x = 0; x < k; ++x) if (x != a[i]) prvnx[i][x] = i;
    for (int x = 0; x < k; ++x) prvnx[i + 1][x] = prvnx[i][x];
  }
  for (int x = 0; x < k; ++x) nxtx[n][x] = nxtnx[n][x] = n;
  for (int i = n - 1; i >= 0; --i) {
    for (int x = 0; x < k; ++x) nxtx[i][x] = nxtx[i + 1][x];
    nxtx[i][a[i]] = i;
    for (int x = 0; x < k; ++x) nxtnx[i][x] = nxtnx[i + 1][x];
    for (int x = 0; x < k; ++x) if (x != a[i]) nxtnx[i][x] = i;
  }
  memset(dp1, -1, sizeof(dp1));
  memset(dp2, -1, sizeof(dp2));
  int ans = n;
  for (int x = 0; x < k; ++x) ans = min(ans, calc1(0, n - 1, x));
  cout << ans << '\n';
}
 
int main() {
  int t;
  cin >> t;
  while (t--) solve();
}

for _ in range(int(input())):
    n = int(input())
    s = input()
    print(sum([s.count(chr(ord('A') + i)) >= i + 1 for i in range(26)]))

#include<bits/stdc++.h>
 
using namespace std;
 
void solve()
{
	int n, k;
	cin >> n >> k;
	vector<int> a(n);
	for(int i = 0; i < n; i++) a[i] = n - i;
	reverse(a.end() - k - 1, a.end());
	for(int i = 0; i < n; i++)
	{
		if(i) cout << " ";
		cout << a[i];
	}
	cout << endl;
}
 
int main()
{
	int t;
	cin >> t;
	for(int i = 0; i < t; i++)
		solve();
	return 0;
}

fun main() = repeat(readLine()!!.toInt()) {
  val (n, k) = readLine()!!.split(" ").map { it.toInt() }
  val a = readLine()!!.split(" ").map { it.toInt() }
  val b = readLine()!!.split(" ").map { it.toInt() }
  var (res, sum, mx) = intArrayOf(0, 0, 0)
  for (i in 0 until minOf(n, k)) {
    sum += a[i]
    mx = maxOf(mx, b[i])
    res = maxOf(res, sum + mx * (k - i - 1))
  }
  println(res)
}

for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = list(map(int, input().split()))
	c = list(map(int, input().split()))
	
	def get_best3(a):
		mx1, mx2, mx3 = -1, -1, -1
		for i in range(len(a)):
			if mx1 == -1 or a[i] > a[mx1]:
				mx3 = mx2
				mx2 = mx1
				mx1 = i
			elif mx2 == -1 or a[i] > a[mx2]:
				mx3 = mx2
				mx2 = i
			elif mx3 == -1 or a[i] > a[mx3]:
				mx3 = i
		return (mx1, mx2, mx3)
	
	ans = 0
	for x in get_best3(a):
		for y in get_best3(b):
			for z in get_best3(c):
				if x != y and x != z and y != z:
					ans = max(ans, a[x] + b[y] + c[z])
	print(ans)

#include<bits/stdc++.h>
 
using namespace std;
 
#define fore(i, l, r) for(int i = int(l); i < int(r); i++)
#define sz(a) int((a).size())
 
typedef long long li;
 
// S = sum a_i - sum b_i
// if Bob made all steps: then S = 0 - sum (b_i - 1)
// each Alice step: S += (a_i - 1) + (b_i - 1) i. e. the bigger (a_i + b_i) the better
 
int n;
vector<int> a, b;
 
inline bool read() {
	if(!(cin >> n))
		return false;
	a.resize(n);
	b.resize(n);
	fore (i, 0, n)
		cin >> a[i];
	fore (i, 0, n)
		cin >> b[i];
	return true;
}
 
inline void solve() {
	vector<int> ids(n);
	iota(ids.begin(), ids.end(), 0);
	
	sort(ids.begin(), ids.end(), [&](int i, int j) {
		return a[i] + b[i] > a[j] + b[j];
	});
	
	li S = 0;
	fore (i, 0, n) {
		if (i & 1)
			S -= b[ids[i]] - 1;
		else
			S += a[ids[i]] - 1;
	}
	cout << S << endl;
}
 
int main() {
#ifdef _DEBUG
	freopen("input.txt", "r", stdin);
	int tt = clock();
#endif
//	ios_base::sync_with_stdio(false);
//	cin.tie(0), cout.tie(0);
	cout << fixed << setprecision(15);
	int t;
	cin >> t;
	for(int i = 0; i < t; i++)
	{
	if(read()) {
		solve();
		
#ifdef _DEBUG
		cerr << "TIME = " << clock() - tt << endl;
		tt = clock();
#endif
	}
	}
	return 0;
}

#include <bits/stdc++.h>
 
using namespace std;
 
const int N = 222222;
 
int n;
int sz[N];
vector<int> g[N];
 
void init(int v) {
  sz[v] = 1;
  for (int u : g[v]) {
    init(u);
    sz[v] += sz[u];
  }
}
 
int calc(int v, int k) {
  int tot = 0, mx = -1;
  for (int u : g[v]) {
    tot += sz[u];
    if (mx == -1 || sz[mx] < sz[u]) mx = u;
  }
  if (tot == 0) return 0;
  if (sz[mx] - k <= tot - sz[mx])
    return (tot - k) / 2;
  int add = tot - sz[mx];
  return add + calc(mx, max(0, k + add - 1));
}
 
int main() {
  ios::sync_with_stdio(false); cin.tie(0);
  int t;
  cin >> t;
  while (t--) {
    cin >> n;
    for (int i = 0; i < n; ++i) g[i].clear();
    for (int i = 1; i < n; ++i) {
      int p; cin >> p;
      g[p - 1].push_back(i);
    }
    init(0);
    cout << calc(0, 0) << '\n';
  }
}

#include<bits/stdc++.h>
 
using namespace std;
 
const int MOD = 998244353;
 
int add(int x, int y)
{
	return (((x + y) % MOD) + MOD) % MOD;
}
 
int mul(int x, int y)
{
	return (x * 1ll * y) % MOD;
}
 
mt19937_64 rnd(98275314);
 
long long gen()
{
	long long x = 0;
	while(x == 0)
		x = rnd();
	return x;
}
 
vector<int> c;
vector<int> g;
 
int process_block(int l, int r)
{
	int ans = 0;
	while(l < r)
	{
		if(g[l] != -1 && g[l] < r)
			l = g[l];
		else
		{
			ans++;
			l++;
		}
	}
	return ans;
}
 
void solve()
{
	int n;
	scanf("%d", &n);
	int size = 0, cnt = 1;
	c.resize(n * 2);
	g.resize(n * 2, -1);
	for(int i = 0; i < 2 * n; i++)
	{
		scanf("%d", &c[i]);
		--c[i];
	}
	
	vector<long long> val(n);
	for(int i = 0; i < n; i++) val[i] = gen();
	
	map<long long, int> last;
	long long cur = 0;
	last[0] = 0;
	for(int i = 0; i < n * 2; i++)
	{
		cur ^= val[c[i]];
		if(cur == 0)
		{
			size++;
			cnt = mul(cnt, process_block(last[0], i + 1));
			last.clear();
		}
		else if(last.count(cur))
		{
			g[last[cur]] = i + 1;
		}
		last[cur] = i + 1;
	}
	
	printf("%d %d\n", size, cnt);
	c.clear();
	g.clear();
}
 
int main()
{
	int t;
	scanf("%d", &t);
	for(int i = 0; i < t; i++) solve();
}