#include<bits/stdc++.h>
using namespace std;
#define ln node<<1
#define rn node<<1|1
#define mid (l+r>>1)
const int N=3e5+99,M=6e5+99;
int n,m,q,k,rt;
struct edge{
    int v,nxt;
}edg[M];
int cntedge,hd[N];
void add(int u,int v){
    cntedge++;
    edg[cntedge]=(edge){v,hd[u]};
    hd[u]=cntedge;
}

int dfn[N],low[N],instack[N],bel[N],cnt[N],scc;
stack<int> sta;
vector<int> to[N];
void tarjan(int u){
    sta.push(u); instack[u]=1;
    dfn[u]=low[u]=++dfn[0];
    int v;
    for(int i=hd[u];i;i=edg[i].nxt){
        v=edg[i].v;
        if(!dfn[v]){
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v])
            low[u]=min(low[u],dfn[v]);
    }
    if(dfn[u]==low[u]){
        ++scc;
        do{
            v=sta.top(); sta.pop();
            bel[v]=scc; cnt[scc]++;
            instack[v]=0;
        }while(v!=u);
    }
}
int in[N],tim[N];
void get_dag(){
    int u,v;
    for(u=1;u<=n;u++){
        for(int i=hd[u];i;i=edg[i].nxt){
            v=edg[i].v;
            if(bel[u]!=bel[v])
                to[bel[u]].push_back(bel[v]),in[bel[v]]++;
        }
    }
    queue<int> que;
    for(int i=1;i<=scc;i++)
        if(!in[i]){
            rt=i;
            que.push(i);
        }
    while(!que.empty()){
        u=que.front(); que.pop();
        tim[u]=++tim[0];
        for(int i=0;i<to[u].size();i++){
            v=to[u][i]; in[v]--;
            if(!in[v]) que.push(v);
        }
    }
    return;
}
bool cmp(int A,int B){
    return tim[A]<tim[B];
}
int vis[N];
void dfs_tree(int u){
    vis[u]=1;
    for(int v:to[u]){
        if(!vis[v]){
            add(u,v);
            dfs_tree(v);
        }
    }
}
void get_tree(){
    memset(hd,0,sizeof(hd)); cntedge=0;
    for(int i=1;i<=scc;i++)
        if(!to[i].empty())
            sort(to[i].begin(),to[i].end(),cmp);
    dfs_tree(rt);
    return;
}


int idfn[N],sz[N],dep[N],son[N],sum[N];
void dfs(int u,int fa){
    sz[u]=1; son[u]=0;
    dep[u]=dep[fa]+1;
    sum[u]=sum[fa]+cnt[u];
    int v;
    for(int i=hd[u];i;i=edg[i].nxt){
        v=edg[i].v;
        if(v!=fa){
            dfs(v,u);
            sz[u]+=sz[v];
            if(sz[v]>sz[son[u]]) son[u]=v;
        }
    }
    return;
}
int ed[N],f[N],gf[N];
void dfs2(int u,int fa,int anc){
    dfn[u]=++dfn[0];
    idfn[dfn[0]]=u;
    f[u]=fa; gf[u]=anc;
    if(son[u])
        dfs2(son[u],u,anc);
    int v;
    for(int i=hd[u];i;i=edg[i].nxt){
        v=edg[i].v;
        if(v!=fa&&v!=son[u])
            dfs2(v,u,v);
    }
    ed[u]=dfn[0];
    return;
}
int lca(int u,int v){
    while(u!=v){
        if(dfn[u]<=dfn[v]&&ed[v]<=ed[u]) return u;
        if(dfn[v]<=dfn[u]&&ed[u]<=ed[v]) return v;
        if(dep[gf[u]]>=dep[gf[v]]) u=f[gf[u]];
        else v=f[gf[v]];
    }
    return u;
}
int au[3],av[3];
vector<int> nd,exnd;
bool cmpp(int A,int B){
	return dfn[A]<dfn[B];
}
int staa[N],stacnt;
vector<int> rev[N];
int nf[N],nval[N];
bool judge(int x,int y){
	return dfn[x]<=dfn[y]&&ed[y]<=ed[x];
}
int viss[N],vist[N];
void dfss(int u){
	viss[u]=1;
	for(int v:to[u])
		if(!viss[v])
			dfss(v);
	return;
}
void dfst(int u){
	vist[u]=1;
	for(int v:rev[u])
		if(!vist[v])
			dfst(v);
	return;
}
void solve(int s,int t){
	int u,v;
	for(int i=0;i<nd.size();i++)
		for(int j=i+1;j<nd.size();j++)
			exnd.push_back(lca(nd[i],nd[j]));
	sort(exnd.begin(),exnd.end());
	exnd.erase(unique(exnd.begin(),exnd.end()),exnd.end());
	sort(exnd.begin(),exnd.end(),cmpp);
	stacnt=0;
	for(int i=0;i<exnd.size();i++){
		u=exnd[i];
		while(stacnt&&!judge(staa[stacnt],u)) stacnt--;
		if(stacnt){
			to[staa[stacnt]].push_back(u);
			rev[u].push_back(staa[stacnt]);
			nf[u]=staa[stacnt];
			nval[u]=sum[u]-sum[nf[u]]-cnt[u];
		}
		staa[++stacnt]=u;
	}
	for(int i=1;i<=k;i++){
		to[au[i]].push_back(av[i]);
		rev[av[i]].push_back(au[i]);
	}
	dfss(s); dfst(t);
	int ans=0;
	for(int i=0;i<exnd.size();i++){
		u=exnd[i];
		vis[u]=(viss[u]&vist[u]);
		if(vis[u]) ans+=cnt[u];
		if(vis[u]&&vis[nf[u]]) ans+=nval[u];
	}
	cout<<ans<<'\n';
	for(int i=0;i<exnd.size();i++){
		u=exnd[i];
		to[u].clear();
		rev[u].clear();
		viss[u]=vist[u]=vis[u]=0;
	}
	return;
}

char ch;
void read(int &re){
	re=0; ch=getchar();
	while(ch<'0'||ch>'9') ch=getchar();
	while(ch>='0'&&ch<='9') re=re*10+ch-'0',ch=getchar();
}
int main(){
//    freopen("celebration.in","r",stdin);
//    freopen("celebration.out","w",stdout);
    std::ios::sync_with_stdio(false);
    cin.tie(0);
	read(n); read(m); read(q); read(k);
    int u,v,s,t;
    for(int i=1;i<=m;i++)
        read(u),read(v),add(u,v);
    for(int i=1;i<=n;i++)
        if(!dfn[i])
            tarjan(i);
    get_dag(); get_tree();
    memset(dfn,0,sizeof(dfn));
    dfs(rt,0); dfs2(rt,0,rt);
    n=scc;
    for(int i=1;i<=n;i++)
    	to[i].clear();
    memset(vis,0,sizeof(vis));
    while(q--){
		read(s); read(t);
		nd.clear(); exnd.clear();
        s=bel[s]; t=bel[t];
        nd.push_back(s); exnd.push_back(s);
        nd.push_back(t); exnd.push_back(t);
        for(int i=1;i<=k;i++){
			read(au[i]); read(av[i]);
            au[i]=bel[au[i]]; av[i]=bel[av[i]];
            nd.push_back(au[i]); exnd.push_back(au[i]);
            nd.push_back(av[i]); exnd.push_back(av[i]);
        }
        solve(s,t);
    }
    return 0;
}