#include<fstream>
#include<vector>
#include<queue>

using namespace std;
typedef int var;

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

#define MAXN 32001

var ST[MAXN], CTC[MAXN], nrctc, t;
vector<var> NODES[MAXN];
var n;
vector<var> Gc[MAXN], G[MAXN], G2[MAXN];
bool VIZ[MAXN];
void dfs1(var node) {
    VIZ[node] = 1;
    for(auto vec : G[node]) {
        if(!VIZ[vec])
            dfs1(vec);
    }
    ST[++t] = node;
}
void dfs2(var node, var ctc) {
    VIZ[node] = 0;
    CTC[node] = ctc;
    NODES[ctc].push_back(node);

    for(auto vec : G2[node]) {
        if(VIZ[vec])
            dfs2(vec, ctc);
    }
}

var D[MAXN];
queue<var> Q;
void topsort(var node) {
    Q.push(node);
    D[node] = 1;
    while(!Q.empty()) {
        node = Q.front();
        Q.pop();
        for(auto vec : Gc[node]) {
            if(!D[vec]) {
                D[vec] = D[node] + 1;
                Q.push(vec);
            }
        }
    }
}


int main()
{
    var m, a, b;
    fin>>n>>m;
    while(m--) {
        fin>>a>>b;
        G[a].push_back(b);
        G2[b].push_back(a);
    }


    for(var i=1; i<=n; i++) {
        if(!VIZ[i])
            dfs1(i);
    }
    for(var i=n; i>=1; i--) {
        if(VIZ[ST[i]]) {
            dfs2(ST[i], ++nrctc);
        }
    }

    for(var i=1; i<=n; i++) {
        for(auto vec : G[i]) {
            if(CTC[i] != CTC[vec]) {
                Gc[CTC[i]].push_back(CTC[vec]);
                VIZ[CTC[vec]] = 1;
            }
        }
    }


    /*for(var i=1; i<=nrctc; i++) {
        fout<<i<<" : ";
        for(auto j : NODES[i]) {
            fout<<j<<" ";
        }
        fout<<endl;
    }*/

    var st;
    for(st=1; VIZ[st]; st++);

    topsort(st);

    fin>>m;
    while(m--) {
        fin>>a>>b;
        a = CTC[a];
        b = CTC[b];
        if(a == b || D[a] < D[b]) fout<<"0\n";
        else fout<<D[a] - D[b]<<'\n';
    }

}