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

#define get_max(a,b) ((a)>(b)?(a):(b))
#define get_min(a,b) ((a)<(b)?(a):(b))
#define NMAX_SIZE 32005
#define MMAX_SIZE 64005
#define TMAX_SIZE 100005

using namespace std;


typedef vector < int > ::iterator IT ; 

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

vector < int > G[NMAX_SIZE] , GT[NMAX_SIZE] ;
stack < int > S ;
bool used[NMAX_SIZE];

int N ,M , ctc , Tests, CTC[NMAX_SIZE] , Time[NMAX_SIZE] , lg[20] , level[NMAX_SIZE] , TT[20][NMAX_SIZE], Highest[NMAX_SIZE]	;

void DFM ( int node )
{
	used[node] = true ;
	for ( IT it = G[node].begin() ; it != G[node].end() ; ++it )
		if ( !used[*it] )
			DFM(node);
	S.push(node);
}

void DFP ( int node )
{
	used[node] = true;
	for ( IT it = GT[node].begin() ; it != GT[node].end () ; ++it )
		if ( !used[*it] )
			DFP( *it );
	CTC[node] = ctc;
}

void KosarajuAlgorithm ( void )
{
	int i , j , node;
	for ( i = 1 ; i <= N ; ++i )
		if ( !used[i] )
			DFM(i) ;
	memset ( used , 0 , sizeof (used) );
	for ( ; S.size(); )
	{
		node = S.top();
		if ( !used[node] )
		{
			DFP ( node );
			++ctc;
		}
		S.pop();
	}
}

void TopologicalSort ( int node )
{
	used[node] = true ;
	for ( IT it = GT[node].begin() ; it != G[node].end() ; ++it )
		if ( !used[*it] )
			TopologicalSort ( *it );
	Time[node] = ++Time[0];
}

bool cmp ( int a , int b ) { return Time[a] > Time[b] ;}

void CreateFather ( int node, int father )
{
	used[node] = true ;
	TT[0][node] = father;
	level[node] = level[father] + 1  ;
	for ( IT it = G[node].begin() ; it != G[node].end(); ++it )
		if ( !used[*it] )
			CreateFather ( *it , node );
		else
			if ( level[node] < level[ TT[0][*it] ] )
			    TT[0][*it] = node ;
}

void DFS ( int node )
{
	int x ;
	used[node] = true ;
	for ( IT it = G[node].begin() ; it != G[node].end(); ++it )
		if ( ! used [ x = *it ] )
	{
		DFS ( x );
		if ( level [ Highest[x] ]  < level [ Highest[node] ] )
			Highest[node] = Highest[x];
	}
}
void CreateAncestors ( void )
{
	int i , j ;
	for ( i = 1 ; i <= lg[N] ; ++i )
		for ( j = 1 ; j <= N ; ++j )
			TT[i][j] = TT[i-1][TT[i-1][j]];
	
}
int LCA ( int x , int y)
{
	int i , j ;
	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 ( i = lg[level[y]] ; i >= 0 ; --i )
	        if ( TT[i][x] and TT[i][x] != TT[i][y] )
			{
				x = TT[i][x] ;
				y = TT[i][y];
			}
    return TT[0][x];
}
int main ( void )
{
	int i , j , x  , y , node;
	in >> N >> M ;
	for ( i = 1 ; i <= M ; ++i )
	{
		in >> x >> y ;
		G[x].push_back(y);
		GT[y].push_back(x);
	}
	KosarajuAlgorithm();
	for ( i = 1 ; i <= N ; ++i )
		GT[i].clear();
	for ( i = 1 ; i <= N ; ++i )
		for ( IT it = G[i].begin() ; it != G[i].end() ; ++it )
			if ( CTC[i] != CTC[*it] )
				G[CTC[i]].push_back( CTC[*it] );
	N = ctc;
	memset ( used , 0 , sizeof(used) );
	TopologicalSort( 1  );
	for ( i = 1 ; i <= N ; ++i )
		sort ( GT[i].begin () ,GT[i].end() , cmp );
	for ( i = 1 ; i <= NMAX_SIZE ; ++i )
	   lg[i] = lg[i/2] + 1 ;
	memset ( used , 0 , sizeof(used) );
	CreateFather( 1 , 0 );
	for ( i = 1 ; i <= N ; ++i )
		Highest[i] = TT[0][i];
	for ( i = 1 ; i <= N ; ++i )
		for ( IT it = G[i].begin() ; it != G[i].end() ; ++it )
			if ( TT[0][*it] != i )
			{
				if ( level[i] < level[Highest[*it] ] )
					Highest[ *it ] = i;
			}
	memset ( used , 0 , sizeof(used));
	DFS( 1 );
	for ( i = 1 ; i <= N ; ++i )
		G[i].clear();
	for ( i = 1 ; i <= N ; ++i )
		if ( Highest[i] )
			G[Highest[i]].push_back(i);
	CreateAncestors();		
	 in >> Tests;
	for ( ; Tests > 0 ; --Tests )
	{
		in >> x >> y;
		x = CTC[x] , y = CTC[y];
		int a = LCA ( x , y );
		if ( x == y or a == x )
		{
			out << "0\n";
			continue;
		}
		int Answer = 0 ;
		for ( int step = 17 ; step >= 0 ; --step )
			if ( level[TT[step][x]] > level[a] )
			{
				x = TT[step][x];
				++Answer; 
			}
		out << Answer << "\n";
	}
	in.close();
	out.close();
	return 0;			
}