#include <bits/stdc++.h>

using namespace std;

#define mp make_pair
#define pb emplace_back
#define rep(i, s, e) for (int i = s; i <= e; ++i)
#define drep(i, s, e) for (int i = s; i >= e; --i)
#define file(a) freopen(#a".in", "r", stdin), freopen(#a".out", "w", stdout)
#define pv(a) cout << #a << " = " << a << endl
#define pa(a, l, r) cout << #a " : "; rep(_, l, r) cout << a[_] << ' '; cout << endl

using pii = pair <int, int>;

const int N = 1e5 + 10;

int read() {
  int x = 0, f = 1; char c = getchar();
  for (; c < '0' || c > '9'; c = getchar()) if (c == '-') f = -1;
  for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48;
  return x * f;
}

int n, q, p[N], dep[N], fp[N][20], ans[N];
vector <int> e[N], dis[N];
vector <pii> qry[N];

struct node {
  int d, u;
  node(int _d = 0, int _u = 0) {
    d = _d, u = _u;
  }
  friend node operator + (node a, int b) {
    return node(a.d + b, a.u);
  }
  friend bool operator < (node a, node b) {
    return a.d == b.d ? a.u < b.u : a.d < b.d;
  }
  friend bool operator == (node a, node b) {
    return a.d == b.d && a.u == b.u;
  }
  void print() {
    printf("(%d, %d)\n", d, u);
  }
} up[N], down[N], mx;

void dfs0(int u, int fa) {
  p[u] = fa;
  for (int v : e[u]) if (v != fa) {
    dep[v] = dep[u] + 1, dfs0(v, u), down[u] = max(down[u], down[v] + 1);
  }
}

void dfs1(int u, int fa) {
  node x, y;
  auto upd = [&](node d) {
    if (x < d) y = x, x = d;
    else if (y < d) y = d;
  } ;
  for (int v : e[u]) if (v != fa) upd(down[v] + 1);
  for (int v : e[u]) if (v != fa) {
    up[v] = up[u] + 1;
    if (down[v] + 1 == x) up[v] = max(up[v], y + 1);
    else up[v] = max(up[v], x + 1);
    dfs1(v, u);
  }
}

int main() {
  n = read(), q = read();
  rep(i, 1, n - 1) {
    int u = read(), v = read();
    e[u].pb(v), e[v].pb(u);
  }
  rep(i, 1, q) {
    int u = read(), d = read();
    qry[u].pb(mp(d, i));
  }
  rep(i, 1, n) down[i] = up[i] = node(0, i);
  dfs0(1, 0), dfs1(1, 0);
  rep(u, 1, n) fp[u][0] = p[u];
  rep(i, 1, 19) rep(u, 1, n) fp[u][i] = fp[fp[u][i - 1]][i - 1];
  auto anc = [&](int u, int k) {
    drep(i, 19, 0) if (k >> i & 1) u = fp[u][i];
    return u;
  } ;
  auto LCA = [&](int u, int v) {
    if (dep[u] < dep[v]) swap(u, v);
    drep(i, 19, 0) if (dep[u] - dep[v] >> i & 1) u = fp[u][i];
    if (u == v) return u;
    drep(i, 19, 0) if (fp[u][i] != fp[v][i]) u = fp[u][i], v = fp[v][i];
    return fp[u][0];
  } ;
  auto kth = [&](int u, int v, int k) {
    int lca = LCA(u, v), dist = dep[u] + dep[v] - 2 * dep[lca];
    if (dep[u] - dep[lca] >= k) return anc(u, k);
    else return anc(v, dist - k);
  } ;
  rep(u, 1, n) {
    dis[u].pb(up[u].d);
    for (int v : e[u]) if (p[v] == u) dis[u].pb(down[v].d + 1);
    sort(dis[u].begin(), dis[u].end());
  }
  rep(u, 1, n) if (qry[u].size()) {
    mx = max(down[u], up[u]);
    for (auto [d, id] : qry[u]) {
      int deg = dis[u].size() - (lower_bound(dis[u].begin(), dis[u].end(), node(d, 0)) - dis[u].begin());
      // pv(deg);
      // cout << "dis[u] : ";
      // for (auto it : dis[u]) cout << it << ' ';
      // cout << endl;
      if (d <= 2 * (deg - 1)) {
        ans[id] = d;
        int pos = lower_bound(dis[u].begin(), dis[u].end(), d) - dis[u].begin();
        if (pos) ans[id] += dis[u][pos - 1];
      }
      else {
        // pv(u);
        // down[u].print();
        // up[u].print();
        // cout << "d, u = " << mx.d << ' ' << mx.u << endl;
        // pv(d);
        int res = d + mx.d, t = (d - 2 * (deg - 1) - 1) / 2, v = kth(u, mx.u, t);
        // cout << "t, v = " << t << ' ' << v << endl;
        // cout << "dis[v] : ";
        // for (auto it : dis[v]) cout << it << ' ';
        // cout << endl;
        int se = dis[u].size() == 1 ? 0 : dis[u][dis[u].size() - 2];
        // pv(se);
        if (v == u) res = min(res, d + se);
        else {
          int w = kth(u, mx.u, t - 1), len = t + se;
          // pv(len);
          // pv(w);
          if (p[v] == w) len = max(len, up[v].d);
          else len = max(len, down[w].d + 1);
          int pos = lower_bound(dis[v].begin(), dis[v].end(), d - t) - dis[v].begin();
          if (pos) len = max(len, dis[v][pos - 1]);
          res = min(res, d - t + len);
          // if (mx[v].d == d - t) res = min(res, d - t + se[v].d);
          // else res = min(res, d - t + mx[v].d);
        }
        ans[id] = res;
      }
    }
  }
  rep(i, 1, q) printf("%d\n", ans[i]);
  return 0;
}