#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 , , CTC[NMAX_SIZE] , time[NMAX_SIZE] , Lg[NMAX_SIZE] , 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.pus(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 );
		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 UltimateDFS( int node )
{
	
}

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);
	memset ( used , 0 , sizeof( used) ) ;
	UltimateDFS(1);
		
	 in >> Tests;
	for ( ; Tests > 0 ; --Tests )
	{
		
	}
	in.close();
	out.close();
	return 0;			
}