#include <bits/stdc++.h>

using namespace std;
ifstream fin("obiective.in");
ofstream fout("obiective.out");
int n,m;
const int NMAX = 32010;
vector<pair<int,bool>> graf[NMAX];
unsigned short memo[29000][29000];
bool calculated[20000];
int currentSearch = -1;
bool inCue[NMAX];
struct comparer{
    bool operator()(const int& a, const int& b)
    {
        return memo[currentSearch][a]>memo[currentSearch][b];
    }
};
int representativeGroup[NMAX];
vector<vector<pair<int,bool>>> graf2;
void dijkstra(int start)
{

    priority_queue<int,vector<int>,comparer> cue;
    start = representativeGroup[start];
    cue.push(start);
    inCue[start] = true;
    memo[start][start] = 1;
    while(cue.size())
    {
        int cueTop = cue.top();
        inCue[cueTop] = false;
        cue.pop();
        for(int i = 0;i<graf2[cueTop].size();i++)
        {
            if(memo[start][graf2[cueTop][i].first]>memo[start][cueTop]+(int)graf2[cueTop][i].second||memo[start][graf2[cueTop][i].first]==0)
            {
                  memo[start][graf2[cueTop][i].first] = memo[start][cueTop]+graf2[cueTop][i].second;
                  if(!inCue[graf2[cueTop][i].first])
                  {
                      inCue[graf2[cueTop][i].first] = true;
                      cue.push(graf2[cueTop][i].first);
                  }
            }
        }
    }
    calculated[start] = true;
}
int viz[NMAX];
void dfsPlus(int start)
{
    queue<int> cue;
    cue.push(start);
    viz[start] = start;
    while(cue.size())
    {
        for(int i = 0;i<graf[cue.front()].size();i++)
        {
            if(viz[graf[cue.front()][i].first]!=start && !graf[cue.front()][i].second)
            {
                viz[graf[cue.front()][i].first] = start;
                cue.push(graf[cue.front()][i].first);
            }
        }
        cue.pop();
    }
}

void dfsMinus(int start)
{
    vector<pair<int,bool>> newNode;
    queue<int> cue;
    cue.push(start);
    viz[start] = -start;
    newNode.push_back({start,false});
    representativeGroup[start] = graf2.size();
    while(cue.size())
    {
        for(int i = 0;i<graf[cue.front()].size();i++)
        {
            if(viz[graf[cue.front()][i].first]!=-999999 &&viz[graf[cue.front()][i].first]!=-start  && graf[cue.front()][i].second)
            {
                if(viz[graf[cue.front()][i].first]==start)
                {
                    newNode.push_back({graf[cue.front()][i].first,false});
                    representativeGroup[graf[cue.front()][i].first] = graf2.size();
                    viz[graf[cue.front()][i].first] = -start;

                }
                else{
                    viz[graf[cue.front()][i].first] = -999999;
                }
                cue.push(graf[cue.front()][i].first);
            }
        }
        cue.pop();
    }
    graf2.push_back(newNode);
}
int main()
{
    fin>>n>>m;
    for(int i = 0;i<m;i++)
    {
        int u,v;
        fin>>u>>v;
        graf[u].push_back({v,false});
        graf[v].push_back({u,true});
    }
    for(int i = 1;i<=n;i++)
    {
        if(viz[i]== -999999 ||viz[i]==-99999999|| viz[i] >= 0)
        {
            dfsPlus(i);
            dfsMinus(i);
        }
    }
    for(int i = 0;i<graf2.size();i++)
    {
        vector<pair<int,bool>> adderNew;
        vector<short> newSizer(graf2.size(),2);
        for(int j = 0;j<graf2[i].size();j++)
        {
            for(int k = 0;k<graf[graf2[i][j].first].size();k++)
            {
                newSizer[representativeGroup[graf[graf2[i][j].first][k].first]] = min(newSizer[representativeGroup[graf[graf2[i][j].first][k].first]],
                                                                                      (graf[graf2[i][j].first][k].second==true)?((short)1):((short)0));
            }
        }
        for(int j = 0;j<graf2.size();j++)
        {
            if(newSizer[j]!=2 && j != i)
                adderNew.push_back({j,(newSizer[j]==1)?(true):(false)});
        }
        graf2[i] = adderNew;
    }

    int t;
    fin>>t;
    while(t--)
    {
        int g,p;
        fin>>g>>p;
        currentSearch = representativeGroup[g];
        if(!calculated[representativeGroup[g]])
        {
            dijkstra(g);
        }
        fout<<memo[representativeGroup[g]][representativeGroup[p]]-1<<'\n';
    }
    return 0;
}