Last Christmas, you had a lovely Christmas tree with (n) vertices, numbered from (1) to (n) and rooted at vertex (1). For each (i) ((2 \le i \le n)), vertex (p_i) is the parent of vertex (i). The tree is decorated beautifully with (a_i) ornaments on vertex (i) ((1 \le i \le n)). However, it has already been a few months since Christmas, and it is time to take down all the ornaments and put your tree away until next year. Since this process is tedious, you have decided to make it more fun by using only the following operation, which you can perform zero or more times: Choose a vertex (u). For each vertex (v) on the unique simple path from vertex (1) to vertex (u) (inclusive), remove exactly one ornament from (v) if there is any left. While you are still determining the minimum number of operations needed, your little child modifies the number of ornaments on the tree. More precisely, your child makes (q) changes. In the (j)-th change, the number of ornaments on vertex (u_j) is modified to (x_j) ((1 \le j \le q)). Note that these changes are persistent; the effect of each change carries over to subsequent changes. Note that you do not actually perform any operations on the tree. For the initial configuration and after each change, your task is to determine the minimum number of operations needed to remove all the ornaments from the tree at each moment. The first line of input contains one integer (t) ((1 \le t \le 10\,000)) representing the number of test cases. After that, (t) test cases follow. Each of them is presented as follows. The first line of each test case contains two integers (n) and (q) ((2 \le n \le 200\,000); (1 \le q \le 200\,000)). The second line contains (n-1) integers (p_2, p_3, \ldots, p_n) ((1 \le p_i \lt i) for all (2 \le i \le n)). The third line contains (n) integers (a_1, a_2, \ldots, a_n) ($$$1 \le