#ifndef LOCAL
    #pragma GCC optimize("O3")
    #pragma GCC target("avx2")
#endif

#ifdef LOCAL
    #define _GLIBCXX_DEBUG
#endif

#include <bits/stdc++.h>
#define pb push_back
#define pii pair<int, int>
using ll = long long;
using ci = const int;
using cll = const long long;

using namespace std;

const int NMAX = 32005;
const int LOG_MAX = 15;
/*******************************/
// INPUT / OUTPUT

#ifndef LOCAL
    ifstream in("obiective.in");
    ofstream out("obiective.out");
    #define cin in
    #define cout out
#endif
/*******************************/
/// GLOBAL DECLARATIONS

int N, M, Q;
int comps, rad;
int vis[NMAX], culoare[NMAX], h[NMAX], dist[NMAX], ins[NMAX], par_a[NMAX], par_b[NMAX];
int tata[LOG_MAX][NMAX];

vector <int> ord;
vector <int> adj[NMAX], inv_adj[NMAX], cg[NMAX];
/*******************************/
/// FUNCTIONS

void ReadInput();
void Solution();
void Output();
/*******************************/
///-------------------------------------
inline void ReadInput()
{
    cin >> N >> M;

    int a, b;
    for (int i = 0 ; i < M ; ++ i)
    {
        cin >> a >> b;

        adj[a].push_back(b);
        inv_adj[b].push_back(a);
    }

    cin >> Q;
}
///-------------------------------------
inline void dfs1(int node)
{
    if (vis[node]) return;

    vis[node] = true;
    for (auto u: adj[node])
        dfs1(u);
    
    ord.push_back(node);
}
///-------------------------------------
inline void dfs2(int node)
{
    if (culoare[node]) return;

    culoare[node] = comps;
    for (auto u: inv_adj[node])
        dfs2(u);
}
///-------------------------------------
inline void dfs(int node, int par)
{
    tata[0][node] = par;
    h[node] = h[par] + 1;

    for (auto u: cg[node])
    {
        if (u == par) continue;

        dfs(u, node);
    }
}
///-------------------------------------
inline int lca(int a, int b)
{
    if (h[a] < h[b]) swap(a, b);

    int dt = h[a] - h[b];
    for (int put = LOG_MAX - 1 ; put >= 0 ; -- put)
    {
        if (dt & (1 << put))
            a = tata[put][a];
    }

    if (a == b) return a;

    for (int put = LOG_MAX - 1 ; put >= 0 ; -- put)
    {
        if (tata[put][a] != tata[put][b])
        {
            a = tata[put][a];
            b = tata[put][b];
        }
    }

    a = tata[0][a];
    return a;
}
///-------------------------------------
inline bool dfs_test(int node, int target, bool care)
{
    vis[node] = true;
    if (node == target)
    {
        if (!care) par_a[node] = true;
        else par_b[node] = true;

        return true;
    }

    bool ok = false;
    for (auto u: cg[node])
    {
        if (!vis[u]) dfs_test(u, target, care);

        if (!care) ok |= par_a[u];
        else ok |= par_b[u];
    }

    if (!care) par_a[node] = ok;
    else par_b[node] = ok;

    return ok;
}
///-------------------------------------
inline int find_dist(vector <int> &surse, int target)
{
    queue <int> q;

    memset(vis, false, sizeof(vis));

    for (auto sursa: surse)
    {
        vis[sursa] = true;
        dist[sursa] = 0;
        q.push(sursa);
    }    

    int node;
    while (!q.empty())
    {
        node = q.front();
        q.pop();

        if (node == target) return dist[node];

        for (auto u: cg[node])
        {
            if (!vis[u])
            {
                vis[u] = true;
                dist[u] = dist[node] + 1;
                q.push(u);
            }
        }
    }

    return -1;
}
///-------------------------------------
inline void Solution()
{
    for (int i = 1 ; i <= N ; ++ i)
        dfs1(i);

    reverse(ord.begin(), ord.end());
    for (auto node: ord)
    {
        if (!culoare[node])
        {
            ++ comps;
            dfs2(node);
        }
    }

    map <pii, bool> mapa;
    for (int i = 1 ; i <= N ; ++ i)
    {
        for (auto j: adj[i])
        {
            if (culoare[i] == culoare[j]) continue;

            if (!mapa[{culoare[i], culoare[j]}])
            {
                mapa[{culoare[i], culoare[j]}];
                cg[culoare[i]].push_back(culoare[j]);

                ins[culoare[j]] ++;
            }
        }
    }

    for (int i = 1 ; i <= comps ; ++ i)
        if (!ins[i])
            rad = i;

    dfs(rad, 0);

    for (int put = 1 ; put < LOG_MAX ; ++ put)
    {
        for (int i = 1 ; i <= comps ; ++ i)
        {
            tata[put][i] = tata[put - 1][tata[put - 1][i]];
        }
    }

    vector <int> surse;
    int a, b, stramos;
    while (Q --)
    {
        cin >> a >> b;

        a = culoare[a]; b = culoare[b];
        memset(vis, false, sizeof(vis));
        memset(par_a, false, sizeof(par_a));
        dfs_test(rad, a, false);

        memset(vis, false, sizeof(vis));
        memset(par_b, false, sizeof(par_b));
        dfs_test(rad, b, true);

        if (par_b[a])
        {
            cout << "0\n";
        }
        else
        {
            int mini = NMAX;
            surse.clear();
            for (int i = 1 ; i <= comps ; ++ i)
            {
                if (par_a[i] && par_b[i])
                {
                    surse.push_back(i);
                }
            }
            cout << find_dist(surse, a) << "\n";
        }
        /*
        stramos = lca(a, b);

        if (stramos == a)
        {
            cout << "0\n";
        }
        else
        {
            cout << h[a] - h[stramos] << "\n";
        }
        */
    }
}
///-------------------------------------
inline void Output()
{

}
///-------------------------------------
int main()
{
    #ifndef LOCAL
        ios::sync_with_stdio(false);
        cin.tie(NULL);
        cout.tie(NULL);
    #endif
    ReadInput();
    Solution();
    Output();
    return 0;
}