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

#define NMAX 32005
#define VEC(G) G[nod][i]

using namespace std;

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

int m,t;
short n,CTC[NMAX],nr,timp[NMAX],low[18][NMAX],TT[18][NMAX],level[NMAX],lg[NMAX];
vector<short> G[NMAX],GT[NMAX];
stack<short> S;
bool use[NMAX];

void read()
{
    fin>>n>>m;
    for(short x,y;m;m--)
    {
        fin>>x>>y;
        G[x].push_back(y);
        GT[y].push_back(x);
    }
    fin>>t;
}

void PM(short nod)
{
    use[nod]=1;
    for(size_t i=0;i<G[nod].size();i++)
        if(!use[VEC(G)])
            PM(VEC(G));
    S.push(nod);
}

void Kosaraju(short nod)
{
    use[nod]=1;
    CTC[nod]=nr;
    for(size_t i=0;i<GT[nod].size();i++)
        if(!use[VEC(GT)])
            Kosaraju(VEC(GT));
}

void edges_CTC()
{
    for(int i=1;i<=n;i++)
        GT[i].clear();
    for(int nod=1;nod<=n;nod++)
        for(size_t i=0;i<G[nod].size();i++)
            if(CTC[nod]!=CTC[VEC(G)])
                GT[CTC[nod]].push_back(CTC[VEC(G)]);
    n=nr;
}

void topo(short nod)
{
    use[nod]=1;
    for(size_t i=0;i<GT[nod].size();i++)
        if(!use[VEC(GT)])
            topo(VEC(GT));
    timp[nod]=++timp[0];
}

bool cmp(const short a,const short b)
{
    return timp[a]>timp[b];
}

void forward(short nod,short tt)
{
    use[nod]=1;
    TT[0][nod]=tt;
    level[nod]=level[tt]+1;
    low[0][nod]=tt;
    for(size_t i=0;i<GT[nod].size();i++)
        if(!use[VEC(GT)])
            forward(VEC(GT),nod);
        else
            if(level[nod]<level[low[0][VEC(GT)]])
                low[0][VEC(GT)]=nod;
}

void lowest(short nod)
{
    use[nod]=1;
    for(size_t i=0;i<GT[nod].size();i++)
        if(!use[VEC(GT)])
        {
            lowest(VEC(GT));
            if(level[low[0][nod]]>level[low[0][VEC(GT)]])
                low[0][nod]=low[0][VEC(GT)];
        }
}

int LCA(short x,short y)
{
    if(level[x]<level[y])
        swap(x,y);
    for(int d=level[x]-level[y];d;x=TT[lg[d]][x],d-=(1<<lg[d]));
    if(x==y)
        return x;
    for(int i=lg[level[y]];i>=0;i--)
        if(TT[i][x] && TT[i][x]!=TT[i][y])
        {
            x=TT[i][x];
            y=TT[i][y];
        }
    return TT[0][x];
}

void ancestors()
{
    for(int i=1;i<=lg[n];i++)
        for(int j=1;j<=n;j++)
        {
            TT[i][j]=TT[i-1][TT[i-1][j]];
            low[i][j]=low[i-1][low[i-1][j]];
        }
}

int main()
{
    read();
    for(int i=2;i<=n;i++)
        lg[i]=lg[i/2]+1;
    for(int i=1;i<=n;i++)
        if(!use[i])
            PM(i);

    memset(use,0,sizeof use);
    for(;!S.empty();S.pop())
        if(!use[S.top()])
        {
            ++nr;
            Kosaraju(S.top());
        }

    edges_CTC();

    memset(use,0,sizeof use);
    topo(1);
    for(int i=1;i<=n;i++)
        sort(GT[i].begin(),GT[i].end(),cmp);

    memset(use,0,sizeof use);
    forward(1,0);
    memset(use,0,sizeof use);
    lowest(1);

    ancestors();

    for(short x,y,L,sol;t;t--)
    {
        fin>>x>>y;
        x=CTC[x];
        y=CTC[y];
        L=LCA(x,y);
        if(x==y || L==x)
        {
            fout<<"0\n";
            continue;
        }
        sol=0;
        for(int step=17;step>=0;step--)
            if(level[low[step][x]]>level[L])
            {
                x=low[step][x];
                sol+=(1<<step);
            }
        fout<<sol+1<<'\n';
    }
    return 0;
}