Synchronization

A company runs $N$ servers around the world. Each server initially stores one unique piece of information: server $i$ stores information $i$, and no two servers start with the same piece.

The company connects servers with communication lines so information can be shared. Whenever two servers become able to reach each other through the currently active lines, they synchronize: after synchronizing, every server in the same connected group holds the union of all pieces that any server in that group held. In other words, servers that are connected (directly or indirectly) always share exactly the same set of pieces.

To keep costs down, only $N-1$ lines are ever installed, and they are chosen so that, if all of them were active at the same time, the servers would form a single tree (there is a unique simple path between any two servers).

At time $0$, no line is active. Because some lines run through harsh environments, a line may go down and later be rebuilt. At each time $j$ (for $1 \le j \le M$) the state of exactly one line changes: if that line is currently inactive it becomes active, and if it is currently active it becomes inactive. All synchronization triggered by a change at time $j$ finishes before time $j+1$.

Important: information is never lost. When an active line goes down and a group splits into two, each side keeps every piece it already held.

After all $M$ changes have been applied, report, for several chosen servers, how many distinct pieces of information that server holds.

The input is given through standard input in the following format.

• The first line contains three integers $N$, $M$, and $Q$: the number of servers, the number of line-state changes, and the number of servers to query.
• Each of the next $N-1$ lines contains two integers $X_i$ and $Y_i$ ($1 \le i \le N-1$): line $i$, when active, connects server $X_i$ and server $Y_i$.
• Each of the next $M$ lines contains one integer $D_j$ ($1 \le j \le M$): at time $j$ the state of line $D_j$ is toggled.
• Each of the next $Q$ lines contains one integer $C_k$ ($1 \le k \le Q$): report the number of distinct pieces of information held by server $C_k$ after all changes.

Print $Q$ lines. The $k$-th line must contain a single integer: the number of distinct pieces of information held by server $C_k$ after all $M$ changes have been applied.

• $2 \le N \le 100\,000$.
• $1 \le M \le 200\,000$.
• $1 \le Q \le N$.
• $1 \le X_i, Y_i \le N$ and $X_i \ne Y_i$ for $1 \le i \le N-1$.
• $1 \le D_j \le N-1$ for $1 \le j \le M$.
• $1 \le C_k \le N$ for $1 \le k \le Q$.
• All values $C_k$ are distinct.
• If every line is active at once, the servers are connected (the $N-1$ lines form a tree).

Consider the first sample, with $5$ servers. At the start server $i$ holds piece $i$ (for $1 \le i \le 5$).

• Time $1$: line $1$ becomes active and connects servers $1$ and $2$. Both now hold $\{1, 2\}$.
• Time $2$: line $2$ becomes active and connects servers $1$ and $3$. Together with line $1$, servers $1$, $2$, $3$ are connected and all hold $\{1, 2, 3\}$.
• Time $3$: line $1$ goes down (it was active). Servers $1$ and $2$ can no longer reach each other, but each keeps $\{1, 2, 3\}$.
• Time $4$: line $4$ becomes active and connects servers $2$ and $5$. Both now hold $\{1, 2, 3, 5\}$. They cannot reach server $1$, because line $1$ is down.
• Time $5$: line $4$ goes down. Servers $2$ and $5$ each keep $\{1, 2, 3, 5\}$.
• Time $6$: line $3$ becomes active and connects servers $2$ and $4$. Both now hold $\{1, 2, 3, 4, 5\}$.

In the end servers $1$, $4$, and $5$ hold $3$, $5$, and $4$ distinct pieces respectively, which matches the first sample's output.