#include <bits/stdc++.h>
#define EB emplace_back
using std::cin;
using std::cout;

typedef std::pair <int, int> pr;
typedef std::vector <int> vector;
const int N = 50054, M = 100054;

int n, q;
vector G[N];
int qu[M], qv[M], ans[M];
int stamp = 0, tag[N], pos[N];
int que[N], du[N], dv[N];

inline void down(int &x, const int y) {x > y ? x = y : 0;}
inline int min(const int x, const int y) {return x < y ? x : y;}
inline void link(int u, int v) {G[u].EB(v), G[v].EB(u);}

void bfs(int s, int *d) {
	int h, t = 1, x;
	d[s] = 0, *que = s;
	for (h = 0; h < t; ++h) {
		x = que[h];
		for (int y : G[x])
			if (tag[y] == stamp && d[y] == INT_MAX) d[y] = d[x] + 1, que[t++] = y;
	}
}

void partition(const vector &V, const vector &qs) {
	int n = V.size();
	if (n < 4) return;
	int i, j, x, y, cur, dist = 0, mu = 0, mv = 1;
	vector vl, vr, ql, qr, eu, ev;
	vector::iterator it;
	for (++stamp, i = 0; i < n; ++i) tag[V[i]] = stamp, pos[V[i]] = i;
	for (i = 0; i < n; ++i) {
		x = V[i], du[x] = dv[x] = INT_MAX;
		for (int y : G[x]) if (tag[y] == stamp && i < (j = pos[y])) {
			cur = min(j - i, n - (j - i));
			if (cur > dist) dist = cur, mu = i, mv = j;
		}
	}
	assert(dist > 1), bfs(V[mu], du), bfs(V[mv], dv);
	vl.assign(V.begin() + mu, V.begin() + (mv + 1)),
	vr.assign(V.begin() + mv, V.end()), vr.insert(vr.end(), V.begin(), V.begin() + (mu + 1));
	it = std::partition(G[V[mu]].begin(), G[V[mu]].end(), [mu, mv] (const int x) {return mu < pos[x] && pos[x] < mv;});
	eu.assign(it, G[V[mu]].end()), G[V[mu]].erase(it, G[V[mu]].end());
	it = std::partition(G[V[mv]].begin(), G[V[mv]].end(), [mu, mv] (const int x) {return mu < pos[x] && pos[x] < mv;});
	ev.assign(it, G[V[mv]].end()), G[V[mv]].erase(it, G[V[mv]].end());
	for (int id : qs) {
		x = qu[id], y = qv[id],
		down(ans[id], du[x] + du[y]),
		down(ans[id], dv[x] + dv[y]),
		x = pos[x], y = pos[y];
		if (x > y) std::swap(x, y);
		if (mu < x && y < mv) ql.EB(id);
		if (mv < x || y < mu || (mv < y && x < mu)) qr.EB(id);
	}
	partition(vl, ql), G[V[mu]].swap(eu), G[V[mv]].swap(ev), partition(vr, qr);
}

int main() {
	int i, u, v; vector v0, q0;
	std::ios::sync_with_stdio(false), cin.tie(NULL);
	cin >> n, link(1, n);
	for (i = 1; i < n; ++i) link(i, i + 1);
	for (i = 3; i < n; ++i) cin >> u >> v, link(u, v);
	cin >> q;
	for (i = 0; i < q; ++i) {
		cin >> qu[i] >> qv[i];
		if (qu[i] > qv[i]) std::swap(qu[i], qv[i]);
		ans[i] = min(qv[i] - qu[i], n - (qv[i] - qu[i]));
		if (ans[i] > 1) q0.EB(i);
	}
	v0.resize(n), std::iota(v0.begin(), v0.end(), 1),
	partition(v0, q0);
	for (i = 0; i < q; ++i) cout << ans[i] << '\n';
	return 0;
}