// Original C++ solution (slower):
#include<iostream>

#include<cstdio>

#include<vector>

#include<queue>

#include<map>

#include<string>

#include<algorithm>

#include<functional>

#define ll long long

#define inf  999999999

#define pa pair<int,int>

using namespace std;

vector<int> gr[11000];

vector<int> igr[11000];

vector<int> ban;



int v,e;

int visit[11000]={0},gro[11000]={0};



void dfs(int i){

	if(visit[i]==0){

		visit[i]=1;

		for(int k=0;k<gr[i].size();k++) dfs(gr[i][k]);

		ban.push_back(i);

	}

}



void idfs(int i,int h){

	if(visit[i]==0){

		visit[i]=1;

		gro[i]=h;

		for(int k=0;k<igr[i].size();k++) idfs(igr[i][k],h);

	}

}



void kyouren(){

	for(int i=0;i<v;i++){

		dfs(i);

	}

	for(int i=0;i<v;i++) visit[i]=0;

	for(int i=v-1;i>=0;i--){

		idfs(ban[i],ban[i]);

	}





}









int main(){

int s,t,q,aa,aaa;

cin>>v>>e;

for(int i=0;i<e;i++){

cin>>s>>t;

gr[s].push_back(t);

igr[t].push_back(s);

}

kyouren();

cin>>q;

for(int i=0;i<q;i++){

cin>>aa>>aaa;

if(gro[aa]==gro[aaa]) cout<<"1"<<endl;

else cout<<"0"<<endl;

}





return 0;

}

// Optimized solution to the same problem (faster):
    #include <bits/stdc++.h>



//    #include <boost/multiprecision/cpp_int.hpp>

 #define int long long

 #define inf  1000000007

 #define pa pair<int,int>

 #define ll long long

 #define pal pair<double,double>

 #define ppap pair<pa,int>

  #define PI 3.14159265358979323846

  #define paa pair<int,char>

  #define  mp make_pair

  #define  pb push_back

  #define EPS (1e-10)

                                          

//    int dx[8]={0,1,0,-1,1,1,-1,-1};

  //  int dy[8]={1,0,-1,0,-1,1,1,-1};

                                            using namespace std;

                                   			class pa3{

                                            	public:

                                            	int x;

                                   				int y,z;

                                            	pa3(int x=0,int y=0,int z=0):x(x),y(y),z(z) {}

                                            	bool operator < (const pa3 &p) const{

                                            		if(x!=p.x) return x<p.x;

                                            		if(y!=p.y) return y<p.y;

                                            		 return z<p.z;

                                            		//return x != p.x ? x<p.x: y<p.y;

                                            	}

                                   				bool operator > (const pa3 &p) const{

                                            		if(x!=p.x) return x>p.x;

                                            		if(y!=p.y) return y>p.y;

                                            		 return z>p.z;

                                            		//return x != p.x ? x<p.x: y<p.y;

                                            	}

                                            	bool operator == (const pa3 &p) const{

                                            		return x==p.x && y==p.y && z==p.z;

                                            	}

                                            		bool operator != (const pa3 &p) const{

                                            			return !( x==p.x && y==p.y && z==p.z);

                                            	}

                                            

                                            };

                                            

                                            class pa4{

                                            	public:

                                            	int x;

                                            	int y,z,w;

                                            	pa4(int x=0,int y=0,int z=0,int w=0):x(x),y(y),z(z),w(w) {}

                                            	bool operator < (const pa4 &p) const{

                                            		if(x!=p.x) return x<p.x;

                                            		if(y!=p.y) return y<p.y;

                                            		if(z!=p.z)return z<p.z;

                                            		return w<p.w;

                                            		//return x != p.x ? x<p.x: y<p.y;

                                            	}

                                            	bool operator > (const pa4 &p) const{

                                            		if(x!=p.x) return x>p.x;

                                            		if(y!=p.y) return y>p.y;

                                            		if(z!=p.z)return z>p.z;

                                            		return w>p.w;

                                            		//return x != p.x ? x<p.x: y<p.y;

                                            	}

                                            	bool operator == (const pa4 &p) const{

                                            		return x==p.x && y==p.y && z==p.z &&w==p.w;

                                            	}

                                            		

                                            

                                            };

                                            class pa2{

                                            	public:

                                            	int x,y;

                                            	pa2(int x=0,int y=0):x(x),y(y) {}

                                            	pa2 operator + (pa2 p) {return pa2(x+p.x,y+p.y);}

                                            	pa2 operator - (pa2 p) {return pa2(x-p.x,y-p.y);}

                                            	bool operator < (const pa2 &p) const{

                                            		return y != p.y ? y<p.y: x<p.x;

                                            	}

                                            	bool operator > (const pa2 &p) const{

                                            		return x != p.x ? x<p.x: y<p.y;

                                            	}

                                            	bool operator == (const pa2 &p) const{

                                            		return abs(x-p.x)==0 && abs(y-p.y)==0;

                                            	}

                                            	bool operator != (const pa2 &p) const{

                                            		return !(abs(x-p.x)==0 && abs(y-p.y)==0);

                                            	}

                                            		

                                            

                                            };

                                        



                                            class Point{

                                            	public:

                                            	double x,y;

                                            	Point(double x=0,double y=0):x(x),y(y) {}

                                            	Point operator + (Point p) {return Point(x+p.x,y+p.y);}

                                            	Point operator - (Point p) {return Point(x-p.x,y-p.y);}

                                            	Point operator * (double a) {return Point(x*a,y*a);}

                                            	Point operator / (double a) {return Point(x/a,y/a);}

                                            	double absv() {return sqrt(norm());}

                                            	double norm() {return x*x+y*y;}

                                            	bool operator < (const Point &p) const{

                                            		return x != p.x ? x<p.x: y<p.y;

                                            	}

                                            	bool operator == (const Point &p) const{

                                            		return fabs(x-p.x)<EPS && fabs(y-p.y)<EPS;

                                            	}

                                            };

                                            typedef Point Vector;

                                     #define pl pair<int,pas>

                                            struct Segment{

                                            Point p1,p2;

                                            };

                                             double dot(Vector a,Vector b){

                                            	return a.x*b.x+a.y*b.y;

                                            }

                                            double cross(Vector a,Vector b){

                                            	return a.x*b.y-a.y*b.x;

                                            }

                                        

                bool parareru(Point a,Point b,Point c,Point d){

                //	if(abs(cross(a-b,d-c))<EPS)cout<<"dd "<<cross(a-b,d-c)<<endl;

                	return abs(cross(a-b,d-c))<EPS;

                }

                double distance_ls_p(Point a, Point b, Point c) {

                  if ( dot(b-a, c-a) < EPS ) return (c-a).absv();

                  if ( dot(a-b, c-b) < EPS ) return (c-b).absv();

                  return abs(cross(b-a, c-a)) / (b-a).absv();

                }

                bool is_intersected_ls(Segment a,Segment b) {

                	if(a.p1==b.p1||a.p2==b.p1||a.p1==b.p2||a.p2==b.p2) return false;

                	if(parareru((a.p2),(a.p1),(a.p1),(b.p2))&&parareru((a.p2),(a.p1),(a.p1),(b.p1))){

                //		cout<<"sss"<<endl;

                		if(dot(a.p1-b.p1,a.p1-b.p2)<EPS) return true;

                		if(dot(a.p2-b.p1,a.p2-b.p2)<EPS) return true;

                		if(dot(a.p1-b.p1,a.p2-b.p1)<EPS) return true;

                		if(dot(a.p1-b.p2,a.p2-b.p2)<EPS) return true;

                		return false;

                	}

                  else return ( cross(a.p2-a.p1, b.p1-a.p1) * cross(a.p2-a.p1, b.p2-a.p1) < EPS ) && ( cross(b.p2-b.p1, a.p1-b.p1) * cross(b.p2-b.p1, a.p2-b.p1) < EPS );

                }

                 

                double segment_dis(Segment a,Segment b){

                	if(is_intersected_ls(a,b))return 0;

                	double r=distance_ls_p(a.p1, a.p2, b.p1);

                	r=min(r,distance_ls_p(a.p1, a.p2, b.p2));

                	r=min(r,distance_ls_p(b.p1, b.p2, a.p2));

                	r=min(r,distance_ls_p(b.p1, b.p2, a.p1));

                	return r;

                }

                Point intersection_ls(Segment a, Segment b) {

                  Point ba = b.p2-b.p1;

                  double d1 = abs(cross(ba, a.p1-b.p1));

                  double d2 = abs(cross(ba, a.p2-b.p1));

                  double t = d1 / (d1 + d2);

                 

                  return a.p1 + (a.p2-a.p1) * t;

                }

                

                                string itos( int i ) {

                                ostringstream s ;

                                s << i ;

                                return s.str() ;

                                }

                                 

                                int gcd(int v,int b){

                                	if(v>b) return gcd(b,v);

                                	if(v==0)return b;

                                	if(v==b) return b;

                                	if(b%v==0) return v;

                                	return gcd(v,b%v);

                                }

                 

                                double distans(double x1,double y1,double x2,double y2){

                                	double rr=(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);

                                	return sqrt(rr);

                                	

                                }

                                int mod;

ll extgcd(ll a, ll b, ll &x, ll &y) {

    if (b == 0ll) {

        x = 1ll;

        y = 0ll;

        return a;

    }

    ll d = extgcd(b, a%b, y, x);

    y -= a/b * x;

    return d;

}

pa operator+(const pa & l,const pa & r) {   

    return {l.first+r.first,l.second+r.second};                                    

}    

pa operator-(const pa & l,const pa & r) {   

    return {l.first-r.first,l.second-r.second};                                    

} 

                                

                int pr[200010];

                int inv[200010];

                

                int beki(int wa,int rr,int warukazu){

                	if(rr==0) return 1%warukazu;

                	if(rr==1) return wa%warukazu;

                	wa%=warukazu;

                	if(rr%2==1) return ((ll)beki(wa,rr-1,warukazu)*(ll)wa)%warukazu;

                	ll zx=beki(wa,rr/2,warukazu);

                	return (zx*zx)%warukazu;

                }

    double bekid(double w,int r){

    	if(r==0) return 1.0;

    	if(r==1) return w;

    	if(r%2) return bekid(w,r-1)*w;

    	double f=bekid(w,r/2);

    	return f*f;

    }

                

    			int comb(int nn,int rr){

    				int r=pr[nn]*inv[rr];

    				r%=mod;

    				r*=inv[nn-rr];

    				r%=mod;

    				return r;

    			}

                

                void gya(int ert){

                	pr[0]=1;

                	for(int i=1;i<=ert;i++){

                		pr[i]=(pr[i-1]*i)%mod;

                	}

                	inv[ert]=beki(pr[ert],mod-2,mod);

                	

                	for(int i=ert-1;i>=0;i--) inv[i]=inv[i+1]*(i+1)%mod;

                	

                }

                

              //   cin.tie(0);

    		//	ios::sync_with_stdio(false);

    			//priority_queue<pa3,vector<pa3>,greater<pa3>> pq;            

                 //sort(ve.begin(),ve.end(),greater<int>());

    //mt19937(clock_per_sec);

  //  mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()) ;

	   

       

                               //----------------kokomade tenpure------------



int C;

struct kyouren{

private:

	public:

int V;

	vector<vector<int>> gr,igr;

	vector<int> visit,gro,ban;

	void shoki(int N){

		V=N;

			gr.resize(N,{});

			igr.resize(N,{});

		visit.resize(N,0);

		gro.resize(N,0);

	}

	

	void add_edge(int x,int y){

		// 0<= x,y <N

		gr[x].pb(y);

		igr[y].pb(x);

	}

	

	

	

	void dfs(int i){

		if(visit[i]==0){

			visit[i]=1;

			for(int k=0;k<(int)gr[i].size();k++) dfs(gr[i][k]);

			ban.push_back(i);

		}

	}



	void idfs(int i,int h){

		if(visit[i]==0){

			visit[i]=1;

			gro[i]=h;

			for(int k=0;k<(int)igr[i].size();k++) idfs(igr[i][k],h);

		}

	}



	void shori(){

		for(int i=0;i<V;i++){

			dfs(i);

		}

		for(int i=0;i<V;i++) visit[i]=0;

		for(int i=V-1;i>=0;i--){

			idfs(ban[i],ban[i]);

		}

	}

		bool same(int x,int y){

			return gro[x]==gro[y];

		}

		

		int id(int x){

			return gro[x];

		}



	

	



};



kyouren ss;

signed main(){



		  cin.tie(0);

	ios::sync_with_stdio(false);

int n,m;

	cin>>n>>m;

	ss.shoki(n);

	for(int i=0;i<m;i++){

		int y,yy;

		cin>>y>>yy;

		ss.add_edge(y,yy);

		

	}

	ss.shori();

	int q;

	cin>>q;

	for(int i=0;i<q;i++){

		int y,yy;

		cin>>y>>yy;

		cout<<ss.same(y,yy)<<endl;

	}

	return 0;

}


// Fastest known solution for this problem: