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

using namespace std;

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

const int nmax = 32e3;
const int logmax = 14;
const int inf = 1 << 30;

int n, nrc, rad;
bool viz[nmax + 1], grnenul[nmax + 1];
int comp[nmax + 1];
vector< int > ord, g[ 2 ][nmax + 1];

int h[nmax + 1], link[nmax + 1];
int d[logmax + 1][nmax + 1];
int l[logmax + 1][nmax + 1];

vector< int > gc[nmax + 1];

void dfs_ctc (int nod, int ind) {
    viz[ nod ] = 1;
    if (ind == 1)
        comp[ nod ] = nrc;

    for (auto i : g[ ind ][ nod ]) {
        if (viz[ i ] == 0) {
            dfs_ctc (i, ind);
        }
    }

    if (ind == 0)
        ord.push_back( nod );
}

void ctc () {
    for (int i = 1; i <= n; ++ i) {
        if (viz[ i ] == 0)
            dfs_ctc (i, 0);
    }

    memset(viz, 0, sizeof(viz));
    reverse(ord.begin(), ord.end());

    for (auto i : ord) {
        if (viz[ i ] == 0) {
            ++ nrc;
            dfs_ctc (i, 1);
        }
    }
}

void trage_muchii_ctc () {
    for (int i = 1; i <= n; ++ i) {
        for (auto j : g[ 0 ][ i ]) {
            if (comp[ i ] != comp[ j ]) {
                gc[ comp[ i ] ].push_back(comp[ j ]);
                grnenul[ comp[ j ] ] = 1;
            }
        }
    }

    for (int i = 1; i <= nrc; ++ i) {
        sort(gc[ i ].begin(), gc[ i ].end());
        gc[ i ].erase(unique(gc[ i ].begin(), gc[ i ].end()), gc[ i ].end());

        if (grnenul[ i ] == 0)
            rad = i;
    }
}

void dfs (int nod) {
    viz[ nod ] = 1;

    for (auto i : gc[ nod ]) {
        if (link[ i ] == 0 || h[ link[ i ] ] > h[ nod ]) {
            link[ i ] = nod;
        }
    }

    for (auto i : gc[ nod ]) {
        if (viz[ i ] == 0) {
            d[ 0 ][ i ] = nod;
            h[ i ] = h[ nod ] + 1;

            dfs( i );

            if (link[ nod ] == 0 || h[ link[ nod ] ] > h[ link[ i ] ]) {
                link[ nod ] = link[ i ];
            }
        }
    }
}

void precalc () {
    for (int i = 1; (1 << i) <= nrc; ++ i) {
        for (int j = 1; j <= nrc; ++ j) {
            d[ i ][ j ] = d[i - 1][ d[i - 1][ j ] ];
        }
    }

    for (int i = 1; i <= nrc; ++ i)
        l[ 0 ][ i ] = link[ i ];

    for (int i = 1; (1 << i) <= nrc; ++ i) {
        for (int j = 1; j <= nrc; ++ j) {
            l[ i ][ j ] = l[i - 1][ l[i - 1][ j ] ];
        }
    }
}

int lca_query (int x, int y) {
    if (h[ x ] > h[ y ])
        swap(x, y);

    int dif = h[ y ] - h[ x ];
    for (int i = logmax; i >= 0; -- i) {
        if (dif & (1 << i))
            y = d[ i ][ y ];
    }

    for (int i = logmax; i >= 0; -- i) {
        if (d[ i ][ x ] != d[ i ][ y ]) {
            x = d[ i ][ x ];
            y = d[ i ][ y ];
        }
    }

    if (x != y)
        x = d[ 0 ][ x ];
    return x;
}

int main () {
    int m;
    fin >> n >> m;

    for (int i = 1; i <= m; ++ i) {
        int x, y;
        fin >> x >> y;
        g[ 0 ][ x ].push_back( y );
        g[ 1 ][ y ].push_back( x );
    }

    ctc ();
    trage_muchii_ctc ();

    memset(viz, 0, sizeof(viz));
    dfs( rad );
    precalc ();

    int t;
    fin >> t;

    for (int i = 1; i <= t; ++ i) {
        int x, y;
        fin >> x >> y;

        x = comp[ x ], y = comp[ y ];

        int lim = h[ lca_query(x, y) ];
        int ans = 0;

        for (int j = logmax; j >= 0; -- j) {
            if (h[ l[ j ][ x ] ] > lim) {
                x = l[ j ][ x ];
                ans += (1 << j);
            }
        }

        if (h[ x ] > lim)
            ++ ans;

        fout << ans << "\n";

    }

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