#include <cstring>
#include <fstream>
#include <algorithm>
#include <set>
#include <vector>

using namespace std;

int N, M, TS;
vector<int> V[32002], P[32002], Q[32002];
set<int> W[32002];
int nodv[32002], minv[32002], where[32002], comps;
int T[32002], Tn[32002], in[32002], out[32002], timp;
int level[32002], lowest[32002];
int str[32002][16];
bool S[32002];
int ST[32002], STP[32002], K[32002];

class compare
{
    public: inline bool operator () (const int& i1, const int& i2)
    {
        return K[i1] < K[i2];
    }
};

inline bool is_str(int x, int y)
{
    return in[x] <= in[y] && out[x] >= out[y];
}

void Tarjan(int x)
{
    S[x] = true;
    nodv[x] = ++nodv[0];
    minv[x] = nodv[x];
    ST[++ST[0]] = x;

    for (vector<int>::iterator it = V[x].begin(); it != V[x].end(); ++it)
    {
        if (!S[*it]) Tarjan(*it);
        if (where[*it] == 0) minv[x] = min(minv[x], minv[*it]);
    }

    if (nodv[x] == minv[x])
    {
        ++comps;
        while (ST[ST[0]] != x)
        {
            where[ST[ST[0]]] = comps;
            --ST[0];
        }
        where[ST[ST[0]]] = comps;
        --ST[0];
    }
}
void sortT(int x)
{
    S[x] = true;
    for (set<int>::iterator it = W[x].begin(); it != W[x].end(); ++it)
        if (!S[*it])
            sortT(*it);
    ST[++ST[0]] = x;
}
void Dfs(int x)
{
    S[x] = true;

    in[x] = ++timp;
    if (x != ST[ST[0]])
        lowest[x] = Tn[x];

    for (vector<int>::iterator it = P[x].begin(); it != P[x].end(); ++it)
    {
        if (!S[*it])
        {
            Tn[*it] = x;
            level[*it] = level[x] + 1;
            Dfs(*it);

            if (x != ST[ST[0]])
                if (level[lowest[*it]] < level[lowest[x]])
                    lowest[x] = lowest[*it];
        }

        if (x != ST[ST[0]])
            if (level[*it] < level[lowest[x]])
                lowest[x] = *it;
    }

    out[x] = ++timp;
}
void goDfs(int x)
{
    STP[++STP[0]] = x;
    for (vector<int>::iterator it = Q[x].begin(); it != Q[x].end(); ++it)
    {
        T[*it] = x;
        goDfs(*it);
    }
    --STP[0];

    for (int i = 0; i <= 15; ++i)
    {
        if (STP[0] >= (1 << i)) str[x][i] = STP[STP[0] - (1 << i) + 1];
        else                    str[x][i] = ST[ST[0]];
    }
}

int main()
{
    ifstream fin("obiective.in");
    ofstream fout("obiective.out");

    fin >> N >> M;
    for (int i = 1, nod1, nod2; i <= M; ++i)
    {
        fin >> nod1 >> nod2;
        V[nod1].push_back(nod2);
    }
    for (int i = 1; i <= N; ++i)
        if (!S[i])
            Tarjan(i);

    for (int i = 1; i <= N; ++i)
        for (vector<int>::iterator it = V[i].begin(); it != V[i].end(); ++it)
            if (where[*it] != where[i])
                W[where[i]].insert(where[*it]);

    memset(S, 0, sizeof(S));
    ST[0] = 0;

    for (int i = 1; i <= comps; ++i)
        if (!S[i])
            sortT(i);

    for (int i = ST[0]; i >= 1; --i)
        K[ST[i]] = ST[0] - i + 1;

    for (int i = 1; i <= comps; ++i)
    {
        for (set<int>::iterator it = W[i].begin(); it != W[i].end(); ++it)
        {
            P[i].push_back(*it);
            P[*it].push_back(i);
        }
        sort(P[i].begin(), P[i].end(), compare());
    }

    memset(S, 0, sizeof(S));
    Dfs(ST[ST[0]]);

    for (int i = 1; i <= comps; ++i)
        if (lowest[i] != 0)
            Q[lowest[i]].push_back(i);

    goDfs(ST[ST[0]]);

    fin >> TS;
    for (int i = 1, nod1, nod2; i <= TS; ++i)
    {
        fin >> nod1 >> nod2;
        nod1 = where[nod1], nod2 = where[nod2];

        if (is_str(nod1, nod2)) fout << 0 << '\n';
        else
        {
            int nodnow = nod1, steps = 0;
            for (int j = 15; j >= 0; --j)
                if (!is_str(str[nodnow][j], nod2))
                {
                    nodnow = str[nodnow][j];
                    steps += (1 << j);
                }
            nodnow = T[nodnow];
            ++steps;

            fout << steps << '\n';
        }
    }

    fin.close();
    fout.close();
}