Brave hero Bitaro challenges a dungeon quest.

The dungeon consists of $N$ rooms numbered from $0, 1, \dots, N-1$. Each room except room $0$ has exactly one parent room. The parent room of room $i$ ($i \ge 1$) is room $P[i]$, and conversely, room $i$ is a child room of room $P[i]$. A room can have multiple child rooms, and room $0$ does not have a parent room.

Bitaro explores the rooms according to the following rules.

• Initially, he must explore room $0$.
• After that, among the unexplored rooms, he chooses and explores one room whose parent room has already been explored.

Room $i$ in the dungeon has a difficulty $R[i]$ and a level $L[i]$. The level $L[i]$ of each room does not change. The difficulty $R[i]$ is defined as the number of already explored rooms among the rooms that can be reached by moving $0$ or more times from room $i$ towards its child rooms. For example, the difficulty of an unexplored room is $0$, and the difficulty of room $0$ is always the number of rooms explored so far.

Every time a new room is explored, the following rules are applied to all rooms in the dungeon. Accordingly, monsters may be added to some rooms. Note that monsters can be added to already explored rooms.

• If $L[i] \le R[i]$, $L[i] + (L[i] + 1) + \cdots + R[i]$ monsters are newly added to room $i$.
• If $L[i] > R[i]$, no monsters are added to room $i$.
• No monsters are added to a room with a difficulty of $0$ (an unexplored room).

Since Bitaro wants to minimize fighting, when exploring a new room, he selects the room that minimizes the total number of newly added monsters in the entire dungeon immediately after the exploration. If there are multiple such rooms, he selects the room with the smallest number.

However, Bitaro knows $P[i]$ but does not know $L[i]$. To find $L[i]$ out, he can choose and investigate one of the explorable rooms to learn its level $L[i]$.

Help Bitaro successfully complete the dungeon quest.

Before implementing the functions, you must include the "brave.h" header file using #include "brave.h".

You must implement the following function.

void bitaroTravel(int N, std::vector P)

• $N$: the number of rooms
• $P$: an array of length $N$ representing the parent room of each room (defined as $P[0] = 0$)
• This function is called exactly once per test case.
• Inside this function, you must call the following two functions to simulate Bitaro's exploration.

int explore(int i)

• $i$: the number of the room to newly explore ($0 \le i \le N - 1$)
• In the first call, you must explore room $0$.
• In subsequent calls, room $i$ must be unexplored, and room $P[i]$ must already be explored.
• If the condition is not met, it returns $-1$. (This is independent of whether the exploration rule is violated.)
• Otherwise, it returns $1$.

int investigate(int i)

• $i$: the room number to investigate ($0 \le i \le N - 1$)
• At this time, room $i$ must be unexplored, and room $P[i]$ must be explored.
• Every room can be investigated at most once. That is, you cannot investigate the same room multiple times.
• If the conditions are not satisfied, it returns $-1$.
• Otherwise, it returns $L[i]$.

After exploring all rooms by calling the explore function a total of $N$ times, the bitaroTravel function must terminate.

After termination, if the order of exploring the rooms meets the problem's conditions, you will receive an Accepted!! verdict; otherwise, you will receive a Wrong Answer verdict.You must not execute any I/O functions in any part of the submitted source code.

• $2 \leq N \leq 300\ 000$.
• $1 \leq L[i] \leq 10$ ($0 \le i \le N - 1$).
• $P[0]=0$.
• $0 \le P[i] < i$ ($1 \le i \le N - 1$).