#include <stdio.h>
#include <atcoder/all>
#include <bits/stdc++.h>
using namespace std;
using namespace atcoder;
using mint = modint998244353;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define Inf32 1000000001
#define Inf64 4000000000000000001LL
struct bcc_graph {
	public:
    bcc_graph() : bcc_graph(0) {}
    bcc_graph(int n) {
		_n = n;
	}

    void add_edge(int from, int to) {
		assert(from != to);
        assert(0 <= from && from < _n);
        assert(0 <= to && to < _n);
		edges.push_back({from,to});
		answer.clear();
    }
	
	void dfs(int u){
		ord[u] = low[u] = _ord++;
		for(int i=start[u];i<start[u+1];i++){
			int v = edges[elist[i]].first ^ edges[elist[i]].second ^ u;
			if(ord[v]==-1){
				dfs(v);
				low[u] = min(low[u],low[v]);
			}
			else{
				if(ord[v] >= ord[u])continue;
				low[u] = min(low[u],ord[v]);
			}
		}
	}
	
	void dfs2(int u,int ci){
		f[u] = true;
		for(int i=start[u];i<start[u+1];i++){
			int e = elist[i];
			if(fe[e])continue;
			fe[e] = true;
			int v = edges[e].first ^ edges[e].second ^ u;
			if(f[v]){
				answer[ci].push_back(e);
				continue;
			}
			if(low[v] < ord[u]){
				answer[ci].push_back(e);
				dfs2(v,ci);
			}
			else{
				int ii = answer.size();
				answer.push_back({e});
				dfs2(v,ii);
			}
		}
	}

    std::vector<std::vector<int>> bcc_edges() {
		if(answer.size()>0)return answer;
		{
			start.assign(_n + 1, 0);
			elist.resize(edges.size()*2);
			for (auto e : edges) {
				start[e.first + 1]++;
				start[e.second + 1]++;
			}
			for (int i = 1; i <= _n; i++) {
				start[i] += start[i - 1];
			}
			auto counter = start;
			rep(i,edges.size()){
				elist[counter[edges[i].first]++] = i;
				elist[counter[edges[i].second]++] = i;
			}	
		}
		
		ord.assign(_n,-1);
		low.assign(_n,-1);
		_ord = 0;
		rep(i,_n){
			if(ord[i]==-1){
				dfs(i);
			}
		}
		f.assign(_n,false);
		fe.assign(edges.size(),false);
		rep(i,_n){
			if(!f[i]){
				dfs2(i,-1);
			}
		}
		return answer;
	}
	
	std::vector<std::vector<int>> bcc_vertecies() {
		
		vector<int> ind(_n,-1);
		if(answer.size()==0)bcc_edges();
		
		vector<vector<int>> res(answer.size());
		rep(i,answer.size()){
			rep(j,answer[i].size()){
				rep(k,2){
					int x = edges[answer[i][j]].first;
					if(k)x = edges[answer[i][j]].second;
					if(ind[x]<i){
						ind[x] = i;
						res[i].push_back(x);
					}
				}
			}
		}
		rep(i,_n){
			if(ind[i]==-1)res.push_back({i});
		}
		return res;
	}

  private:
    int _n,_ord;
	vector<int> start;
    vector<int> elist;
	vector<pair<int,int>> edges;
	vector<int> ord,low;
	vector<bool> f,fe;
	vector<vector<int>> answer;
};
struct HLD{
	vector<int> sz,parent,depth,root,pos;
	vector<int> arr;
	HLD(vector<vector<int>> &E){
		sz.resize(E.size(),1);
		parent.resize(E.size(),0);
		depth.resize(E.size(),0);
		root.resize(E.size(),0);
		pos.resize(E.size(),0);
		
		dfs(0,-1,E);
		dfs2(0,-1,E,0);
	}
	
	void dfs(int now,int p,vector<vector<int>> &E){
		parent[now] = p;
		if(p==-1){
			depth[now] = 0;
		}
		else{
			depth[now] = depth[p]+1;
		}
		for(int i=0;i<E[now].size();i++){
			int to = E[now][i];
			if(to==p)continue;
			dfs(to,now,E);
			sz[now] += sz[to];
		}
	}
	
	void dfs2(int now,int p,vector<vector<int>> &E,int r){
		pos[now] = arr.size();
		arr.push_back(now);
		root[now] = r;
		int maxi = 0;
		int ind = -1;
		for(int i=0;i<E[now].size();i++){
			int to = E[now][i];
			if(to==p)continue;
			if(maxi<sz[to]){
				maxi = sz[to];
				ind = to;
			}
		}
		if(ind==-1)return;
		dfs2(ind,now,E,r);
		for(int i=0;i<E[now].size();i++){
			int to = E[now][i];
			if(to==p||to==ind)continue;
			dfs2(to,now,E,to);
		}
	}
	
	vector<pair<int,int>> query(int u,int v){
		vector<pair<int,int>> ret;
		int t = 0;
		while(root[u]!=root[v]){
			if(depth[root[u]] <= depth[root[v]]){
				ret.insert(ret.begin()+t,{pos[root[v]], pos[v]});
				v = parent[root[v]];
			}
			else{
				ret.insert(ret.begin()+t,{pos[u],pos[root[u]]});
				u = parent[root[u]];
				t++;
			}
		}
		ret.insert(ret.begin()+t,{pos[u],pos[v]});
		return ret;
	}
	
	int lca(int u,int v){
		for(;;v=parent[root[v]]){
			if(pos[u]>pos[v])swap(u,v);
			if(root[u]==root[v])return u;
		}
	}
	
	int get_distance(int u,int v){
		return depth[u] + depth[v] - 2 * depth[lca(u,v)];
	}
	
};
int main(){

	int n,m;
	cin>>n>>m;
	
	bcc_graph B(n);
	rep(i,m){
		int u,v;
		cin>>u>>v;
		u--,v--;
		B.add_edge(u,v);
	}
	auto b = B.bcc_vertecies();
	vector<int> d(n);
	rep(i,b.size()){
		rep(j,b[i].size()){
			d[b[i][j]] ++;
		}
	}
	vector<vector<int>> E(b.size());
	vector<int> blocks(n,-1);
	rep(i,n){
		if(d[i]>=2){
			blocks[i] = E.size();
			E.push_back({});
		}
	}
	rep(i,b.size()){
		rep(j,b[i].size()){
			if(blocks[b[i][j]]!=-1){
				E[blocks[b[i][j]]].push_back(i);
				E[i].push_back(blocks[b[i][j]]);
			}
			else{
				blocks[b[i][j]] = i;
			}
		}
	}
	HLD H(E);
	fenwick_tree<int> F(E.size());
	rep(i,E.size()){
		if(i < b.size())continue;
		F.add(H.pos[i],1);
	}
	int _q;
	cin>>_q;
	rep(_,_q){
		int x,y;
		cin>>x>>y;
		if(x==y){
			cout<<0<<endl;
			continue;
		}
		x--,y--;
		x = blocks[x],y = blocks[y];
		auto t = H.query(x,y);
		int ans = 0;
		rep(i,t.size()){
			int l = t[i].first,r = t[i].second;
			if(l>r)swap(l,r);
			ans += F.sum(l,r+1);
		}
		if(x>=b.size())ans--;
		if(y>=b.size())ans--;
		cout<<ans<<endl;
	}
	
	return 0;
}