#include <iostream>
#include <vector>
#include <functional>
#include <cstdint>
#include <cmath>

#define dbg(x) std::cerr << #x << " = " << x << "\n";

using Graph = std::vector<std::vector<int>>;
using i64 = std::int64_t;

struct Node {
  int l = 0, r = 0;
  int sum = 0;
};

struct PersistentSegmentTree {
  PersistentSegmentTree(const int N, const int nodes_count) : N(N) {
    T.reserve(nodes_count);
    T.emplace_back();
  }

  [[nodiscard]] int add(const int u, const int l, const int r, const int pos, const int value) {
    auto idx = this->new_();
    T[idx] = T[u];
    if (l == r) {
      T[idx].sum += value;
    } else {
      const auto m = (l + r) / 2;
      if (pos <= m) {
        T[idx].l = add(T[idx].l, l, m, pos, value);
      } else {
        T[idx].r = add(T[idx].r, m + 1, r, pos, value);
      }
      this->pull(idx);
    }
    return idx;
  }
  [[nodiscard]] int add(const int u, const int pos, const int value) {
    return this->add(u, 0, N - 1, pos, value);
  }

  [[nodiscard]] int join(const int x, const int y, const int l, const int r) {
    if (x == 0 || y == 0) {
      return x + y;
    }
    auto idx = this->new_();
    if (l == r) {
      T[idx].sum = T[x].sum + T[y].sum;
    } else {
      const int m = (l + r) / 2;
      T[idx].l = join(T[x].l, T[y].l, l, m);
      T[idx].r = join(T[x].r, T[y].r, m + 1, r);
    }
    this->pull(idx);
    return idx;
  }
  [[nodiscard]] int join(const int x, const int y) {
    return this->join(x, y, 0, N - 1);
  }

  
  // query function somewhere in here
  std::pair<int, int> query(const int lhs, const int rhs, const int l, const int r, const int k) {
    if (l == r) {
      return {l, k};
    }
    const auto sum = T[T[lhs].l].sum - T[T[rhs].l].sum;
    const auto m = (l + r) / 2;
    if (sum >= k) {
      return query(T[lhs].l, T[rhs].l, l, m, k);
    } else {
      return query(T[lhs].r, T[rhs].r, m + 1, r, k - sum);
    }
  }
  
  std::pair<int, int> query(const int lhs, const int rhs, const int k) {
    return this->query(lhs, rhs, 0, N - 1, k);
  }
  std::pair<int, int> query(const int root, const int k) {
    return this->query(root, 0, k);
  }

  int new_() {
    T.emplace_back();
    return T.size() - 1;
  }

  void pull(const int idx) {
    T[idx].sum = T[T[idx].l].sum + T[T[idx].r].sum;
  }

  int N;
  std::vector<Node> T;
};

int main() {
  int N, Q;
  std::cin >> N >> Q;
  Graph G(N);
  int root = 0;
  std::vector<int> parent(N + 1, N);
  for (int i = 0; i < N; i++) {
    std::cin >> parent[i];
    parent[i]--;
    if (parent[i] == -1) {
      root = i;
    } else {
      G[parent[i]].push_back(i);
    }
  }

  const int max_nodes = std::ceil(1 + std::log2(N)) * N * 2;
  PersistentSegmentTree DS_lca{N, max_nodes}, DS_values{N, max_nodes};
  std::vector<int> root_lca(N), root_values(N);

  std::vector<int> subtree_size(N), depth(N);
  std::vector<std::vector<int>> up(std::ceil(2 + std::log2(N)), std::vector<int>(N + 1, N));
  parent[root] = N;
  std::function<void(const int)> dfs = [&](const int u) -> void {
    up[0][u] = parent[u];
    for (int l = 1; (1 << l) <= N; l++) {
      up[l][u] = up[l - 1][up[l - 1][u]];
    }

    subtree_size[u] = 1;
    for (const int v : G[u]) {
      depth[v] = depth[u] + 1;
      dfs(v);
      subtree_size[u] += subtree_size[v];
    }
  };
  dfs(root);

  std::function<void(const int)> dfs_build = [&](const int u) -> void {
    root_lca[u] = DS_lca.add(root_lca[u], u, subtree_size[u]);
    root_values[u] = DS_values.add(root_values[u], u, 1);
    for (const int v : G[u]) {
      root_lca[v] = root_lca[u];
      root_lca[v] = DS_lca.add(root_lca[v], u, -subtree_size[v]);
      dfs_build(v);
      root_values[u] = DS_values.join(root_values[u], root_values[v]);
    }
  };
  root_lca[root] = DS_lca.new_();
  dfs_build(root);

  auto jump_up = [&](int u, const int delta) -> int {
    for (int i = up.size() - 1; i >= 0; i--) {
      if ((delta & (1 << i)) > 0) {
        u = up[i][u];
      }
    }
    return u;
  };

  for (int i = 0; i < Q; i++) {
    i64 k;
    std::cin >> k;
    int x = (k - 1) / N;
    const int rest = (k - 1) % N  + 1;
    const auto [lca, new_rest] = DS_lca.query(root_lca[x], rest);
    int l_bellow = 0;
    if (lca != x) {
      l_bellow = root_values[jump_up(x, depth[x] - depth[lca] - 1)];
    }
    const auto [y, _] = DS_values.query(root_values[lca], l_bellow, new_rest);
    std::cout << (i64)N * N * x + (i64)N * lca + y << "\n";
  } 
  return 0;
}