#include <bits/stdc++.h>
#define rep(i,j,k) for(int i=(j);i<=(k);i++)
#define per(i,j,k) for(int i=(j);i>=(k);i--)
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define db double
#define ldb long double
#define pii pair<int,int>
#define pll pair<ll,ll>
#define mkp make_pair
#define eb emplace_back
#define SZ(S) (int)S.size()
#define mod 998244353
//#define mod 1000000007
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3f
using namespace std;

template <class T>
void chkmax(T &x,T y){
    if(x < y) x = y;
}

template <class T>
void chkmin(T &x,T y){
    if(x > y) x = y;
}

inline int popcnt(int x){
    return __builtin_popcount(x);
}

inline int ctz(int x){
    return __builtin_ctz(x);
}

template <int P>
class mod_int
{
    using Z = mod_int;

private:
    static int mo(int x) { return x < 0 ? x + P : x; }

public:
    int x;
    int val() const { return x; }
    mod_int() : x(0) {}
    template <class T>
    mod_int(const T &x_) : x(x_ >= 0 && x_ < P ? static_cast<int>(x_) : mo(static_cast<int>(x_ % P))) {}
    bool operator==(const Z &rhs) const { return x == rhs.x; }
    bool operator!=(const Z &rhs) const { return x != rhs.x; }
    Z operator-() const { return Z(x ? P - x : 0); }
    Z pow(long long k) const
    {
        Z res = 1, t = *this;
        while (k)
        {
            if (k & 1)
                res *= t;
            if (k >>= 1)
                t *= t;
        }
        return res;
    }
    Z &operator++()
    {
        x < P - 1 ? ++x : x = 0;
        return *this;
    }
    Z &operator--()
    {
        x ? --x : x = P - 1;
        return *this;
    }
    Z operator++(int)
    {
        Z ret = x;
        x < P - 1 ? ++x : x = 0;
        return ret;
    }
    Z operator--(int)
    {
        Z ret = x;
        x ? --x : x = P - 1;
        return ret;
    }
    Z inv() const { return pow(P - 2); }
    Z &operator+=(const Z &rhs)
    {
        (x += rhs.x) >= P && (x -= P);
        return *this;
    }
    Z &operator-=(const Z &rhs)
    {
        (x -= rhs.x) < 0 && (x += P);
        return *this;
    }
    Z operator-()
    {
        return -x;
    }
    Z &operator*=(const Z &rhs)
    {
        x = 1ULL * x * rhs.x % P;
        return *this;
    }
    Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
#define setO(T, o)                                  \
    friend T operator o(const Z &lhs, const Z &rhs) \
    {                                               \
        Z res = lhs;                                \
        return res o## = rhs;                       \
    }
    setO(Z, +) setO(Z, -) setO(Z, *) setO(Z, /)
#undef setO
    
    friend istream& operator>>(istream& is, mod_int& x)
    {
        long long tmp;
        is >> tmp;
        x = tmp;
        return is;
    }
    friend ostream& operator<<(ostream& os, const mod_int& x)
    {
        os << x.val();
        return os;
    }
};

using Z = mod_int<mod>;
Z power(Z p,ll k){
    Z ans = 1;
    while(k){
        if(k % 2 == 1) ans *= p;
        p *= p;
        k /= 2;
    }
    return ans;
}
Z fact[1000005],ifac[1000005],inv[1000005];

Z C(int N,int M){
    if(N < M || M < 0) return 0;
    return fact[N] * ifac[M] * ifac[N - M];
}

void init(int L){
    fact[0] = 1;
    rep(i,1,L) fact[i] = fact[i - 1] * i;
    ifac[L] = 1 / fact[L];
    per(i,L - 1,0) ifac[i] = ifac[i + 1] * (i + 1);
    rep(i,1,L) inv[i] = ifac[i] * fact[i - 1];
}
int n,m,N,s,t,q;
int val[25][25],id[25];
Z a[25],b[25];
Z ext;

Z dp[1 << 20][20];

Z f[21][1 << 20],g[21][1 << 20],res[1 << 20];
void FWT(Z *F){
    rep(i,0,n - 1){
        rep(S,0,(1 << n) - 1) if((S >> i) & 1) F[S] += F[S - (1 << i)];
    }
}

void iFWT(Z *F){
    rep(i,0,n - 1){
        rep(S,0,(1 << n) - 1) if((S >> i) & 1) F[S] -= F[S - (1 << i)];
    }
}

Z F[21],G[21],ans[21];
int main(){
//    freopen("test.in","r",stdin);
    scanf("%d%d%d%d",&n,&m,&s,&t);
    init(n);
    N = 0;
    rep(u,1,n){
        if(u == s || u == t) continue;
        id[u] = N++;
    }

    rep(i,1,m){
        int u,v;
        scanf("%d%d",&u,&v);
        if(u == s && v == t){
            ext++;
            continue;
        }
        if(v == s || u == t) continue;

        if(u == s) a[id[v]]++;
        else if(v == t) b[id[u]]++;
        else val[id[u]][id[v]]++;
    }

    n = N;
    rep(S,1,(1 << n) - 1){
        if(popcnt(S) == 1){
            int u = __lg(S);
            dp[S][u] = b[u];
            f[popcnt(S)][S] += a[u] * b[u];
            continue;
        }
        Z temp = 0;
        rep(u,0,n - 1){
            if(!((S >> u) & 1)) continue;
            int R = S - (1 << u);
            rep(v,0,n - 1) if((R >> v) & 1) dp[S][u] += val[u][v] * dp[R][v];
            temp += a[u] * dp[S][u];
        }
        f[popcnt(S)][S] += temp;
//        printf("%d %d\n",S,temp.val());
    }
/*    printf("A:\n");
    rep(i,0,n - 1) printf("%d ",a[i].val());
    printf("\n");
    printf("B:\n");
    rep(i,0,n - 1) printf("%d ",b[i].val());
    printf("\n");
    rep(u,0,n - 1){
        rep(v,0,n - 1) printf("%d ",val[u][v]);
        printf("\n");
    }*/
    rep(i,1,n) FWT(f[i]);

    rep(S,0,(1 << n) - 1){
        rep(i,0,n) F[i] = f[i][S];
        G[0] = 1;
        rep(i,0,n - 1){
            G[i + 1] = 0;
            rep(j,0,i) G[i + 1] += (j + 1) * F[j + 1] * G[i - j];
            G[i + 1] *= inv[i + 1];
        }
        rep(i,0,n) g[i][S] = G[i];
    }
    rep(i,1,n) iFWT(g[i]);
    rep(S,0,(1 << n) - 1) res[S] = g[popcnt(S)][S];

    FWT(res);
    rep(S,0,(1 << n) - 1){
        rep(u,0,n - 1) ans[u] += dp[S][u] * a[u] * res[(1 << n) - 1 - S];
    }

    scanf("%d",&q);
    rep(i,1,q){
        int u;
        scanf("%d",&u);
        if(u == t) printf("%d\n",(res[(1 << n) - 1] * ext).val());
        else printf("%d\n",(ans[id[u]] * (ext + 1)).val());
    }
	return 0;
}