#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optmize("unroll-lopps")
#include <bits/stdc++.h>
using namespace std;

using ll = long long;
#define all(v) (v).begin(), (v).end()
#define pb push_back

void dbg_out() { cerr << endl; }
template<typename H, typename... T> 
void dbg_out(H h, T... t) { cerr << ' ' << h; dbg_out(t...); }
#define dbg(...) { cerr << #__VA_ARGS__ << ':'; dbg_out(__VA_ARGS__); cout << endl; }

struct Seg{
	vector<int> lazy;
	vector<int> seg;
	int n;
	void build(int _n){
		n = _n;
		lazy = vector<int> (4*(n+5));
		seg = vector<int> (4*(n+5));
	}
	void propaga(int r, int i, int j){
		seg[r] += lazy[r];
		if(i != j){
			lazy[2*r] += lazy[r];
			lazy[2*r+1] += lazy[r];
		}
		lazy[r] = 0;
	}

	void update(int r, int i, int j, int a, int b,int v){
		propaga(r,i,j);
		if(i > b || a > j) return;
		if(a <= i && j <= b){
			lazy[r] += v;
			propaga(r,i,j);
			return;
		}
		int m = (i+j)/2;
		update(2*r,i,m,a,b,v);
		update(2*r+1,m+1,j,a,b,v);
		seg[r] = max(seg[2*r], seg[2*r+1]);
	}
	int query(int r, int i, int j,int a, int b){
		propaga(r,i,j);
		if(i > b || a > j) return 0;
		if(a <= i && j <= b) return seg[r];
		int m = (i+j)/2;
		int L = query(2*r,i,m,a,b);
		int R = query(2*r+1,m+1,j,a,b);
		return max(L,R);
	}
	int query(int a, int b){
		return query(1,0,n-1,a,b);
	}
	void update(int a, int b,int v){
		update(1,0,n-1,a,b,v);
	}
};
const int MAXN = 1e5+5;
vector<int> g[MAXN];

struct HLD{
	
	Seg seg;
	vector<int> dad,pos,in,out,h;
	int N;
	HLD(int n, vector<int> g[]): dad(n), pos(n), in(n),out(n),h(n){
		N = n;	
		seg.build(n);
		int t = -1;
		function<void(int)> dfs = [&](int u){
			pos[ in[u] = ++t] = u;
			int mx = -1;
			for(int &v : g[u]) if(v != dad[u]){
				dad[v] = u;
				h[v] = g[u][0] == v ? h[u] : v;
				dfs(v);
				if(out[v] - in[v] > mx){
					mx = out[v]-in[v],swap(g[u][0],v);
				}
			}
			out[u] = t;
		};
		dfs(0);
		t = -1;
		dfs(0);
	}
	void update_path(int u, int v, int val){
		while(h[u] != h[v]){
			if(in[h[u]] < in[h[v]]) swap(u,v);
			seg.update(in[h[u]],in[u],val);
			u = dad[h[u]];
		}
		if(in[u] > in[v]) swap(u,v);
		seg.update(in[u],in[v],val);
	}
	int query(){
		return seg.query(0,N-1);
	}
};

int uf[MAXN];

int find(int x){
	return x == uf[x] ? x : uf[x] = find(uf[x]);
}
int uni(int a, int b){
	a = find(a);
	b = find(b);
	if(a == b) return 0;
	uf[a] = b;
	return 1;
}

void solve() {
	int n;
	cin >> n;
	int q;
	cin >> q;
	vector<array<int,2>> sobra;
	for(int i = 0; i < n; i++) uf[i] = i;
	for(int i = 0; i < n+1; i++){
		int a,b;
		cin >> a >> b;
		a--;
		b--;
		if( uni(a,b)){
			g[a].pb(b);
			g[b].pb(a);
		}else{
			sobra.pb({a,b});
		}
	}
	int a = sobra[0][0];
	int b = sobra[0][1];
	int c = sobra[1][0];
	int d = sobra[1][1];
	HLD hld(n,g);
	map<pair<int,int>,int> foi;
	for(int i = 0; i < q; i++){
		int u,v;
		cin >> u >> v;
		u--;
		v--;
		auto par = make_pair(u,v);
		if(foi.find(par) != foi.end()){
			cout << foi[par] << '\n';
			continue;
		}
		vector<vector<pair<int,int>>> ops = {
			{ {u,a},{b,v}},
			{ {u,b},{a,v}},
			{ {u,c},{d,v}},
			{ {u,d},{c,v}},
			{ {u,a},{b,c},{d,v}},
			{ {u,b},{a,c},{d,v}},
			{ {u,a},{b,d},{c,v}},
			{ {u,b},{a,d},{c,v}},
			{ {u,c},{d,a},{b,v}},
			{ {u,c},{d,b},{a,v}},
			{ {u,d},{c,a},{b,v}},
			{ {u,d},{c,b},{a,v}},
		};
		int ans = 1;
		int cnt= 0;
		for(auto y : ops){
			for(auto p : y){
				hld.update_path(p.first,p.second,1);
			}
			int ret =  hld.query() <= 1;
			ans += ret;
			for(auto p : y){
				hld.update_path(p.first,p.second,-1);
			}
		}
		
		cout << (foi[par] = ans) << '\n';
	}

}

signed main() {
	ios::sync_with_stdio(false); cin.tie(0);
	int t= 1;
	while(t--)
		solve();
}