Problem: Alice and Bob are well-known for sending messages to each other. This time you have a rooted tree with Bob standing in the root node and copies of Alice standing in each of the other vertices. The root node has number 0, the rest are numbered 1 through n.

At some moments of time some copies of Alice want to send a message to Bob and receive an answer. We will call this copy the initiator. The process of sending a message contains several steps: 

  * The initiator sends the message to the person standing in the parent node and begins waiting for the answer. 
  * When some copy of Alice receives a message from some of her children nodes, she sends the message to the person standing in the parent node and begins waiting for the answer. 
  * When Bob receives a message from some of his child nodes, he immediately sends the answer to the child node where the message came from. 
  * When some copy of Alice (except for initiator) receives an answer she is waiting for, she immediately sends it to the child vertex where the message came from. 
  * When the initiator receives the answer she is waiting for, she doesn't send it to anybody. 
  * There is a special case: a copy of Alice can't wait for two answers at the same time, so if some copy of Alice receives a message from her child node while she already waits for some answer, she rejects the message and sends a message saying this back to the child node where the message came from. Then the copy of Alice in the child vertex processes this answer as if it was from Bob. 
  * The process of sending a message to a parent node or to a child node is instant but a receiver (a parent or a child) gets a message after 1 second. 



If some copy of Alice receives several messages from child nodes at the same moment while she isn't waiting for an answer, she processes the message from the initiator with the smallest number and rejects all the rest. If some copy of Alice receives messages from children nodes and also receives the answer she is waiting for at the same instant, then Alice first processes the answer, then immediately continue as normal with the incoming messages.

You are given the moments of time when some copy of Alice becomes the initiator and sends a message to Bob. For each message, find the moment of time when the answer (either from Bob or some copy of Alice) will be received by the initiator.

You can assume that if Alice wants to send a message (i.e. become the initiator) while waiting for some answer, she immediately rejects the message and receives an answer from herself in no time.

Input

The first line of input contains two integers n and m (1 ≤ n, m ≤ 200 000) — the number of nodes with Alices and the number of messages.

Second line contains n integers p1, p2, ..., pn (0 ≤ pi < i). The integer pi is the number of the parent node of node i.

The next m lines describe the messages. The i-th of them contains two integers xi and ti (1 ≤ xi ≤ n, 1 ≤ ti ≤ 109) — the number of the vertex of the initiator of the i-th message and the time of the initiation (in seconds). The messages are given in order of increasing initiation time (i.e. ti + 1 ≥ ti holds for 1 ≤ i < m). The pairs (xi, ti) are distinct.

Output

Print m integers — the i-th of them is the moment of time when the answer for the i-th message will be received by the initiator.

Examples

Input

6 3
0 1 2 3 2 5
4 6
6 9
5 11


Output

14 13 11 

Input

3 2
0 1 1
2 1
3 1


Output

5 3 

Input

8 3
0 1 1 2 3 3 4 5
6 1
8 2
4 5


Output

7 6 11 

Note

In the first example the first message is initiated at the moment 6, reaches Bob at the moment 10, and the answer reaches the initiator at the moment 14. The second message reaches vertex 2 at the moment 11. At this moment the copy of Alice in this vertex is still waiting for the answer for the first message, so she rejects the second message. The answer reaches the initiator at the moment 13. The third message is not sent at all, because at the moment 11 Alice in vertex 5 is waiting for the answer for the second message.

In the second example the first message reaches Bob, the second is rejected by Alice in vertex 1. This is because the message with smaller initiator number has the priority.

In the third example the first and the third messages reach Bob, while the second message is rejected by Alice in vertex 3.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, INF = 2e9;
int n, m;
int par[N], depth[N], ans[N], myBegin[N], subSize[N], preOrder[N], preTime;
vector<int> V[N], path[N];
pair<int, int> query[N];
int arr[N];
class IntervalTree {
 public:
  int BASE;
  vector<int> path;
  vector<pair<int, int> > tree;
  vector<int> lazy;
  pair<int, int> better(const pair<int, int> &A, const pair<int, int> &B) {
    return A.first + 2 * depth[A.second] >= B.first + 2 * depth[B.second] ? A
                                                                          : B;
  }
  IntervalTree(vector<int> v) {
    path = v;
    BASE = 1;
    while (BASE < v.size()) {
      BASE *= 2;
    }
    tree.resize(2 * BASE + 1);
    lazy.resize(2 * BASE + 1, -INF - 1);
    for (int i = 0; i < v.size(); i++) {
      tree[i + BASE] = make_pair(-INF, v[i]);
    }
    for (int i = BASE - 1; i >= 1; i--) {
      tree[i] = better(tree[2 * i], tree[2 * i + 1]);
    }
  }
  void propagate(int w, int y) {
    if (lazy[w] != -INF - 1) {
      tree[w] = make_pair(lazy[w], path[y]);
      if (w < BASE) {
        lazy[2 * w] = lazy[w];
        lazy[2 * w + 1] = lazy[w];
      }
      lazy[w] = -INF - 1;
    }
  }
  void insert(int w, int posa, int posb, int x, int y, int value) {
    if (posa > posb) {
      return;
    }
    propagate(w, y);
    if (posa <= x && y <= posb) {
      tree[w] = {value, path[y]};
      if (x < y) {
        lazy[2 * w] = value;
        lazy[2 * w + 1] = value;
      }
      return;
    }
    int mid = (x + y) / 2;
    if (x <= posb && posa <= mid) {
      insert(2 * w, posa, posb, x, mid, value);
      tree[w] = better(tree[w], tree[2 * w]);
    }
    if (mid + 1 <= posb && posa <= y) {
      insert(2 * w + 1, posa, posb, mid + 1, y, value);
      tree[w] = better(tree[w], tree[2 * w + 1]);
    }
  }
  pair<int, int> query(int w, int posa, int posb, int x, int y, int value) {
    propagate(w, y);
    if (posa > posb || tree[w].first + 2 * depth[tree[w].second] <= value) {
      return {-INF - 1, -1};
    }
    if (w >= BASE) {
      if (tree[w].first + 2 * depth[tree[w].second] > value) {
        return tree[w];
      } else {
        return {-INF - 1, -1};
      }
    }
    int mid = (x + y) / 2;
    if (mid + 1 <= posb && posa <= y) {
      pair<int, int> r = query(2 * w + 1, posa, posb, mid + 1, y, value);
      if (r.second != -1) {
        return r;
      }
    }
    if (x <= posb && posa <= mid) {
      pair<int, int> r = query(2 * w, posa, posb, x, mid, value);
      return r;
    } else {
      return {-INF - 1, -1};
    }
  }
};
IntervalTree *intTree[N];
bool cmp(int a, int b) {
  if (depth[query[a].first] + query[a].second ==
      depth[query[b].first] + query[b].second) {
    return query[a].first < query[b].first;
  }
  return depth[query[a].first] + query[a].second <
         depth[query[b].first] + query[b].second;
}
bool cmp2(int a, int b) { return subSize[a] < subSize[b]; }
void DFS(int w) {
  subSize[w] = 1;
  preOrder[w] = ++preTime;
  sort(V[w].begin(), V[w].end());
  for (int i = 0; i < V[w].size(); i++) {
    depth[V[w][i]] = depth[w] + 1;
    DFS(V[w][i]);
    subSize[w] += subSize[V[w][i]];
  }
  sort(V[w].begin(), V[w].end(), cmp2);
}
void DFSHLD(int w, int b) {
  path[b].push_back(w);
  myBegin[w] = b;
  if (!V[w].empty()) {
    DFSHLD(V[w].back(), b);
  }
  for (int i = 0; i < (int)V[w].size() - 1; i++) {
    DFSHLD(V[w][i], V[w][i]);
  }
}
int findMax(int from, int t) {
  int w = from;
  while (true) {
    int HLDpath = myBegin[w];
    pair<int, int> q = intTree[HLDpath]->query(
        1, 0, depth[w] - depth[HLDpath], 0, intTree[HLDpath]->BASE - 1, t);
    if (q.second != -1) {
      return q.second;
    }
    w = par[HLDpath];
  }
  exit(-1);
}
void insert(int from, int to, int t) {
  int w = from;
  while (true) {
    int HLDpath = myBegin[w];
    if (depth[HLDpath] <= depth[to]) {
      intTree[HLDpath]->insert(1, depth[to] - depth[HLDpath] + 1,
                               depth[w] - depth[HLDpath], 0,
                               intTree[HLDpath]->BASE - 1, t);
      break;
    } else {
      intTree[HLDpath]->insert(1, 0, depth[w] - depth[HLDpath], 0,
                               intTree[HLDpath]->BASE - 1, t);
      w = par[HLDpath];
    }
  }
}
int main() {
  scanf("%d %d", &n, &m);
  for (int i = 1; i <= n; i++) {
    scanf("%d", &par[i]);
    V[par[i]].push_back(i);
  }
  DFS(0);
  DFSHLD(0, 0);
  for (int i = 0; i <= n; i++) {
    if (!path[i].empty()) {
      intTree[i] = new IntervalTree(path[i]);
    }
  }
  intTree[0]->insert(1, 0, 0, 0, intTree[0]->BASE - 1, INF);
  for (int i = 1; i <= m; i++) {
    scanf("%d %d", &query[i].first, &query[i].second);
    arr[i] = i;
  }
  sort(arr + 1, arr + 1 + m, cmp);
  for (int i = 1; i <= m; i++) {
    int w = query[arr[i]].first;
    int t = query[arr[i]].second;
    int res = findMax(w, t + depth[w]);
    ans[arr[i]] = t + 2 * (depth[w] - depth[res]);
    insert(w, res, t + depth[w] - 2 * depth[res]);
  }
  for (int i = 1; i <= m; i++) {
    printf("%d ", ans[i]);
  }
  return 0;
}