#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;

#define Nmax 32768
#define Log 32
#define INF 0x3f3f3f3f
#define pb push_back
#define sz(a) (int)((a).size())

int n, m, ct, cnt, niv;
vector<int> lv1[Nmax], lv2[Nmax], lv[Nmax];
int comp[Nmax];
int v[Nmax];
int list[Nmax];
int lvl[Nmax], low[Nmax];
int h[2 * Nmax];
int pos[Nmax];
int ai[4 * Nmax];
int P[Nmax][Log];

void citire()
{
	int i, a, b;

	scanf("%d %d\n", &n, &m);
	for (i = 1; i <= m; ++i)
	{
		scanf("%d %d\n", &a, &b);
		lv1[a].pb(b);
		lv2[b].pb(a);
	}
}

void DF1(int nod)
{
	int i;

	v[nod] = 1;
	for (i = 0; i < sz(lv2[nod]); ++i)
		if (!v[lv2[nod][i]])
			DF1(lv2[nod][i]);

	list[++ct] = nod;
}

void DF2(int nod)
{
	int i;

	comp[nod] = ct;
	for (i = 0; i < sz(lv1[nod]); ++i)
		if (!comp[lv1[nod][i]])
			DF2(lv1[nod][i]);
}

void DF(int nod)
{
	int i;

	v[nod] = 1;
	if (lvl[low[nod]] > lvl[nod]) low[nod] = nod;
    h[++cnt] = lvl[nod];
	pos[nod] = cnt;

	for (i = 0; i < sz(lv[nod]); ++i)
        if (lvl[low[lv[nod][i]]] > lvl[nod]) low[lv[nod][i]] = nod;

	for (i = 0; i < sz(lv[nod]); ++i)
		if (!v[lv[nod][i]])
		{
			lvl[lv[nod][i]] = lvl[nod] + 1;
			DF(lv[nod][i]);
			if (lvl[low[lv[nod][i]]] < lvl[low[nod]]) low[nod] = low[lv[nod][i]];
            h[++cnt] = lvl[nod];
		}
}

void init(int nod, int st, int dr)
{
	if (st == dr)
		ai[nod] = h[st];
	else
	{
		int mij = (st + dr) / 2, fs = nod * 2, fd = nod * 2 + 1;

		init(fs, st, mij);
		init(fd, mij + 1, dr);

		ai[nod] = min(ai[fs], ai[fd]);
	}
}

void query(int nod, int st, int dr, int a, int b)
{
	if (a <= st && dr <= b)
		niv = min(niv, ai[nod]);
	else
	{
		int mij = (st + dr) / 2, fs = nod * 2, fd = nod * 2 + 1;

		if (a <= mij) query(fs, st, mij, a, b);
		if (mij < b) query(fd, mij + 1, dr, a, b);
	}
}

void solve()
{
	int i, j, k, a, b, sol;

	for (i = 1; i <= n; ++i)
		if (!v[i])
			DF1(i);

	reverse(list+1, list+n+1);

	for (ct = 0, i = 1; i <= n; ++i)
		if (!comp[list[i]])
		{
			++ct;
			DF2(list[i]);
		}

	for (i = 1; i <= n; ++i)
		for (j = 0; j < sz(lv1[i]); ++j)
			if (comp[i] != comp[lv1[i][j]])
				lv[comp[i]].pb(comp[lv1[i][j]]);

	for (i = 1; i <= n; ++i)
		sort(lv[i].rbegin(), lv[i].rend());

	memset(low, 0, sizeof(low));
	memset(v, 0, sizeof(v));
	lvl[0] = INF;
	lvl[ct] = 1;

	DF(ct);
	init(1, 1, cnt);

	memset(P[ct], -1, sizeof(P[ct]));
	for (i = ct - 1; i >= 1; --i)
	{
		P[i][0] = low[i];
		for (j = 1; j < Log; ++j)
			if (P[i][j - 1] != -1 && P[P[i][j - 1]][j - 1] != -1)
				P[i][j] = P[P[i][j - 1]][j - 1];
			else
				P[i][j] = -1;
	}

	scanf("%d\n", &k);
	for (i = 1; i <= k; ++i)
	{
		scanf("%d %d\n", &a, &b);
		a = comp[a];
		b = comp[b];

        niv = INF;
		query(1, 1, cnt, min(pos[a], pos[b]), max(pos[a], pos[b]));

		sol = 0;
		for (j = Log - 1; j >= 0; --j)
			if (P[a][j] != -1 && lvl[P[a][j]] > niv)
			{
				a = P[a][j];
				sol += 1 << j;
			}
		if (lvl[P[a][j]] != niv) ++sol;
		
		printf("%d\n", sol);
	}
}

int main()
{
	freopen("obiective.in", "r", stdin);
	freopen("obiective.out", "w", stdout);

	citire();
	solve();

	return 0;
}