#include <bits/stdc++.h>
#define all(x) begin(x), end(x)
#define dbg(x) cerr << #x << " = " << x << endl
#define _ << ' ' <<
using namespace std;
using ll = long long;
using vi = vector<int>;

vi adj[200005], adj2[200005];
int jump[200005][18];
int in[200005], jin[200005], out[200005];
int low[200005];
int sum[200005];
int val[200005];
int tick = 1;

void dfs(int x, int p)
{
    in[x] = low[x] = tick++;
    for (int y : adj[x])
    {
        if (y == p)
            continue;

        if (in[y] == 0)
        {
            adj2[x].push_back(y);
            adj2[y].push_back(x);
            dfs(y, x);
            low[x] = min(low[x], low[y]);
        }
        else
            low[x] = min(low[x], in[y]);
    }
}

void dfs2(int x, int p)
{
    for (int y : adj2[x])
    {
        if (y == p)
            continue;

        if (low[y] >= in[x])
            val[y] = 1;

        sum[y] = sum[x] + val[y];
        dfs2(y, x);
    }
}


void dfs3(int x, int p)
{
    jump[x][0] = (p == -1 ? x : p);
    for (int i = 1; i < 18; ++i)
        jump[x][i] = jump[jump[x][i - 1]][i - 1];

    jin[x] = tick++;
    for (int y : adj2[x])
        if (y != p)
            dfs3(y, x);
    out[x] = tick++;
}

bool is_ancestor(int x, int y)
{
    return jin[x] <= jin[y] && out[y] <= out[x];
}

int lca(int x, int y)
{
    if (is_ancestor(x, y)) return x;
    for (int i = 18 - 1; i >= 0; --i)
        if (!is_ancestor(jump[x][i], y))
            x = jump[x][i];
    return jump[x][0];
}

int llca(int x, int y)
{
    for (int i = 18 - 1; i >= 0; --i)
        if (!is_ancestor(jump[x][i], y))
            x = jump[x][i];
    return x;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < m; ++i)
    {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    dfs(1, -1);
    dfs2(1, -1);
    dfs3(1, -1);

    int q;
    cin >> q;
    while (q--)
    {
        int c, d;
        cin >> c >> d;
        int l = lca(c, d);
        int s = sum[c] + sum[d];
        if (l != c && l != d)
        {
            s -= 2 * sum[l];
            int a = llca(c, d);
            int b = llca(d, c);
            s -= val[a] + val[b];
            s++;
            if (low[a] < in[l] && low[b] < in[l])
                s--;
        }
        else
        {
            if (!is_ancestor(c, d)) swap(c, d);
            int b = llca(d, c);
            s -= sum[l];
            s -= sum[b];
        }
        cout << s << '\n';
    }
}