You are given a rooted tree. It contains $n$ vertices, which are numbered from $1$ to $n$. The root is the vertex $1$.

Each edge has two positive integer values. Thus, two positive integers $a_j$ and $b_j$ are given for each edge.

Output $n-1$ numbers $r_2, r_3, \dots, r_n$, where $r_i$ is defined as follows.

Consider the path from the root (vertex $1$) to $i$ ($2 \le i \le n$). Let the sum of the costs of $a_j$ along this path be $A_i$. Then $r_i$ is equal to the length of the maximum prefix of this path such that the sum of $b_j$ along this prefix does not exceed $A_i$.

Example for $n=9$. The blue color shows the costs of $a_j$, and the red color shows the costs of $b_j$.

Consider an example. In this case:

$r_2=0$, since the path to $2$ has an amount of $a_j$ equal to $5$, only the prefix of this path of length $0$ has a smaller or equal amount of $b_j$;

$r_3=3$, since the path to $3$ has an amount of $a_j$ equal to $5+9+5=19$, the prefix of length $3$ of this path has a sum of $b_j$ equal to $6+10+1=17$ ( the number is $17 \le 19$);

$r_4=1$, since the path to $4$ has an amount of $a_j$ equal to $5+9=14$, the prefix of length $1$ of this path has an amount of $b_j$ equal to $6$ (this is the longest suitable prefix, since the prefix of length $2$ already has an amount of $b_j$ equal to $6+10=16$, which is more than $14$);

$r_5=2$, since the path to $5$ has an amount of $a_j$ equal to $5+9+2=16$, the prefix of length $2$ of this path has a sum of $b_j$ equal to $6+10=16$ (this is the longest suitable prefix, since the prefix of length $3$ already has an amount of $b_j$ equal to $6+10+1=17$, what is more than $16$);

$r_6=1$, since the path up to $6$ has an amount of $a_j$ equal to $2$, the prefix of length $1$ of this path has an amount of $b_j$ equal to $1$;

$r_7=1$, since the path to $7$ has an amount of $a_j$ equal to $5+3=8$, the prefix of length $1$ of this path has an amount of $b_j$ equal to $6$ (this is the longest suitable prefix, since the prefix of length $2$ already has an amount of $b_j$ equal to $6+3=9$, which is more than $8$);

$r_8=2$, since the path up to $8$ has an amount of $a_j$ equal to $2+4=6$, the prefix of length $2$ of this path has an amount of $b_j$ equal to $1+3=4$;

$r_9=3$, since the path to $9$ has an amount of $a_j$ equal to $2+4+1=7$, the prefix of length $3$ of this path has a sum of $b_j$ equal to $1+3+3=7$.


-----Input-----

The first line contains an integer $t$ ($1 \le t \le 10^4$) — the number of test cases in the test.

The descriptions of test cases follow.

Each description begins with a line that contains an integer $n$ ($2 \le n \le 2\cdot10^5$) — the number of vertices in the tree.

This is followed by $n-1$ string, each of which contains three numbers $p_j, a_j, b_j$ ($1 \le p_j \le n$; $1 \le a_j,b_j \le 10^9$) — the ancestor of the vertex $j$, the first and second values an edge that leads from $p_j$ to $j$. The value of $j$ runs through all values from $2$ to $n$ inclusive. It is guaranteed that each set of input data has a correct hanged tree with a root at the vertex $1$.

It is guaranteed that the sum of $n$ over all input test cases does not exceed $2\cdot10^5$.


-----Output-----

For each test case, output $n-1$ integer in one line: $r_2, r_3, \dots, r_n$.


-----Examples-----

Input
4
9
1 5 6
4 5 1
2 9 10
4 2 1
1 2 1
2 3 3
6 4 3
8 1 3
4
1 1 100
2 1 1
3 101 1
4
1 100 1
2 1 1
3 1 101
10
1 1 4
2 3 5
2 5 1
3 4 3
3 1 5
5 3 5
5 2 1
1 3 2
6 2 1
Output
0 3 1 2 1 1 2 3 
0 0 3 
1 2 2 
0 1 2 1 1 2 2 1 1


-----Note-----

The first example is clarified in the statement.

In the second example:

$r_2=0$, since the path to $2$ has an amount of $a_j$ equal to $1$, only the prefix of this path of length $0$ has a smaller or equal amount of $b_j$;

$r_3=0$, since the path to $3$ has an amount of $a_j$ equal to $1+1=2$, the prefix of length $1$ of this path has an amount of $b_j$ equal to $100$ ($100 > 2$);

$r_4=3$, since the path to $4$ has an amount of $a_j$ equal to $1+1+101=103$, the prefix of length $3$ of this path has an amount of $b_j$ equal to $102$, .

Difficulty: MEDIUM_HARD

Solutions:
import sys, threading
import bisect
lines = list(map(str.strip, sys.stdin.readlines()))
sys.setrecursionlimit(10 ** 9)
threading.stack_size(10 ** 8)

def solve():
	i = 1
	while i < len(lines):
		n = int(lines[i])
		ncopy = n
		i += 1
		children = {}
		node = 2
		while n > 1:
			(parent, a, b) = map(int, lines[i].split(' '))
			if parent not in children:
				children[parent] = []
			children[parent].append([node, a, b])
			node += 1
			i += 1
			n -= 1
		result = {}
		taken = []

		def dfs(node, sum):
			result[node] = bisect.bisect_right(taken, sum)
			if node not in children:
				return
			for (child, left, right) in children[node]:
				taken.append((taken[-1] if len(taken) != 0 else 0) + right)
				dfs(child, sum + left)
				taken.pop()
		dfs(1, 0)
		for j in range(2, ncopy + 1):
			print(result[j], end=' ')
		print()
threading.Thread(target=solve).start()


import bisect
for _ in range(int(input())):
	n = int(input())
	child = {i: [] for i in range(1, n + 1)}
	a = {1: 0}
	b = {1: 0}
	cura = 0
	curb = 0
	cumb = []
	for i in range(2, n + 1):
		(pi, ai, bi) = map(int, input().split())
		child[pi].append(i)
		a[i] = ai
		b[i] = bi
	ans = {1: 0}
	q = [1]
	vis = {}
	while q:
		x = q.pop()
		if x in vis:
			cura -= a[x]
			curb -= b[x]
			cumb.pop()
		else:
			cura += a[x]
			curb += b[x]
			cumb.append(curb)
			ans[x] = bisect.bisect_right(cumb, cura) - 1
			q.append(x)
			vis[x] = True
			for i in child[x]:
				q.append(i)
	for i in range(2, n + 1):
		print(ans[i], end=' ')
	print()


import sys
import threading

def dfs(v, p, pans):
	global put, mb, ans
	(l, r) = (-1, len(mb))
	while r > l + 1:
		m = (r + l) // 2
		if mb[m] > pans:
			r = m
		else:
			l = m
	ans[v] = l + 1
	for i in range(len(put[v])):
		if put[v][i][0] != p:
			if len(mb) != 0:
				mb.append(mb[-1] + put[v][i][1][1])
			else:
				mb.append(put[v][i][1][1])
			dfs(put[v][i][0], v, pans + put[v][i][1][0])
			if len(mb) > 0:
				mb.pop()

def main():
	global put, mb, ans
	for _ in range(int(input())):
		n = int(input())
		put = [list() for _ in range(n)]
		for i in range(1, n):
			(p, a, b) = map(int, input().split())
			put[p - 1].append([i, [a, b]])
		(ans, mb) = ([0] * n, list())
		dfs(0, -1, 0)
		for i in range(1, len(ans)):
			print(ans[i], end=' ')
		print()
sys.setrecursionlimit(10 ** 9)
threading.stack_size(10 ** 8)
thread = threading.Thread(target=main)
thread.start()
thread.join()