#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;
}
int n,m;
ll inst;
ll a[25];
Z fact[25],ifac[25],inv[25];
int ord[25],rk[25];

bool cmp(int x,int y){
    return a[x] > a[y];
}
int msk[25],_sum[1 << 15];

Z val[3][16][1 << 15],_ret[1 << 15];
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 tmp[3][25];
void ln(Z *f,Z *g){//f = ln g
    fill(f,f + n + 1,0);
    rep(i,0,n - 1){
        f[i + 1] = (i + 1) * g[i + 1];
        rep(j,0,i - 1) f[i + 1] -= (j + 1) * f[j + 1] * g[i - j];
        f[i + 1] *= inv[i + 1];
    }
}

void Exp(Z *g,Z *f){//g = e^f
    fill(g,g + n + 1,0);
    g[0] = 1;
    rep(i,0,n - 1){
        rep(j,0,i) g[i + 1] += (j + 1) * f[j + 1] * g[i - j];
        g[i + 1] *= inv[i + 1];
    }
}

void conv(Z *f,Z *g,Z *res,int k){//size 是 2^k
    rep(i,0,k){
        fill(val[0][i],val[0][i] + (1 << k),0);
        fill(val[1][i],val[1][i] + (1 << k),0);
    }
    rep(S,0,(1 << k) - 1){
        val[0][popcnt(S)][S] += f[S];
        val[1][popcnt(S)][S] += g[S];
    }
    rep(i,0,k){
        FWT(val[0][i]);
        FWT(val[1][i]);
    }
    rep(S,0,(1 << k) - 1){
        rep(i,0,k){
            tmp[0][i] = val[0][i][S];
            tmp[1][i] = val[1][i][S];
            tmp[2][i] = 0;
        }
        rep(i,0,k){
            rep(j,0,k - i) tmp[2][i + j] += tmp[0][i] * tmp[1][j];
        }
        rep(i,0,k) val[2][i][S] = tmp[2][i];
    }
    rep(i,0,k) iFWT(val[2][i]);
    rep(S,0,(1 << k) - 1) res[S] = val[2][popcnt(S)][S];
}
Z dp[1 << 15],ndp[1 << 15],A[1 << 15],B[1 << 15],C[1 << 15];

Z _dp[2][2],_ndp[2][2],b[25];
Z calc(int S){
//    printf("solve S=%d\n",S);
    Z ans = 0;
    int qwq;
    per(p,59,0){
        _dp[0][0] = 1;_dp[0][1] = _dp[1][0] = _dp[1][1] = 0;
        rep(i,0,n - 1) b[i] = (a[i] & ((1ll << p) - 1)) + 1;
        qwq = 0;
        rep(i,0,n - 1){
            if(!((S >> i) & 1)) continue;

            if((a[i] >> p) & 1){
                rep(v,0,1){
                    _ndp[v][1] += _dp[v][1] * (1ll << p) + _dp[v][0];
                    _ndp[v ^ 1][1] += _dp[v][1] * b[i];
                    _ndp[v ^ 1][0] += _dp[v][0] * b[i];
                }
                qwq ^= 1;
            }else{
                rep(v,0,1){
                    _ndp[v][1] += _dp[v][1] * b[i];
                    _ndp[v][0] += _dp[v][0] * b[i];
                }
            }
            rep(v,0,1){
                rep(o,0,1){
                    _dp[v][o] = _ndp[v][o];
                    _ndp[v][o] = 0;
                }
            }
        }
        ans += _dp[(inst >> p) & 1][1];
        if(qwq != ((inst >> p) & 1)) break;
        if(!p) ans++;
    }
//    printf("%d\n",ans.val());
    return ans;
}

int main(){
//    freopen("test.in","r",stdin);
//    freopen("test.out","w",stdout);
    scanf("%d%d%lld",&n,&m,&inst);
    fact[0] = 1;
    rep(i,1,n) fact[i] = fact[i - 1] * i;
    ifac[n] = Z(1) / fact[n];
    per(i,n - 1,0) ifac[i] = ifac[i + 1] * (i + 1);
    rep(i,1,n) inv[i] = ifac[i] * fact[i - 1];

    rep(u,0,n - 1){
        scanf("%lld",&a[u]);
        ord[u] = u;
    }
    sort(ord,ord + n,cmp);
    rep(i,0,n - 1) rk[ord[i]] = i;
    sort(a,a + n);reverse(a,a + n);
    rep(i,1,m){
        int u,v;
        scanf("%d%d",&u,&v);
        u = rk[u - 1];v = rk[v - 1];
        msk[u] |= 1 << v;msk[v] |= 1 << u;
    }
    rep(S,1,(1 << n) - 1){
        int u = ctz(S);
        _sum[S] = _sum[S - (1 << u)] + popcnt(msk[u] & S);
    }
//    rep(S,0,(1 << n) - 1) printf("S=%d:%d\n",S,_sum[S]);
    rep(S,0,(1 << n) - 1) if(!_sum[S]) val[0][popcnt(S)][S]++;
    rep(i,0,n) FWT(val[0][i]);
    rep(S,0,(1 << n) - 1){
//        printf("S=%d\n",S);
        rep(i,0,n) tmp[1][i] = val[0][i][S];
//        rep(i,0,n) printf("%d ",tmp[1][i].val());
//        printf("\n");
        ln(tmp[0],tmp[1]);
//        rep(i,0,n) printf("%d ",tmp[0][i].val());
//        printf("\n");
        rep(i,0,n) val[1][i][S] = tmp[0][i];
    }
    rep(i,0,n) iFWT(val[1][i]);
    rep(S,0,(1 << n) - 1) _ret[S] = val[1][popcnt(S)][S];
//    printf("ret:\n");
//    rep(S,0,(1 << n) - 1) printf("S=%d:%d\n",S,_ret[S].val());
    rep(i,0,n) fill(val[0][i],val[0][i] + (1 << n),0);
    rep(S,1,(1 << n) - 1) if(!__builtin_parity(S)) val[0][popcnt(S)][S] += _ret[S] * (a[__lg(S)] + 1);
//    rep(S,0,(1 << n) - 1) printf("S=%d:%d\n",S,val[0][popcnt(S)][S].val());
    rep(i,0,n) FWT(val[0][i]);
    rep(S,0,(1 << n) - 1){
//        printf("%d:\n",S);
        rep(i,0,n) tmp[1][i] = val[0][i][S];
        Exp(tmp[0],tmp[1]);
/*        rep(i,0,n) printf("%d ",tmp[1][i].val());
        printf("\n");
        rep(i,0,n) printf("%d ",tmp[0][i].val());
        printf("\n");*/
        rep(i,0,n) val[1][i][S] = tmp[0][i];
    }
    rep(i,0,n) iFWT(val[1][i]);

    rep(S,0,(1 << n) - 1) dp[(1 << n) - 1 - S] = val[1][popcnt(S)][S];
    dp[(1 << n) - 1] = 1;
//    rep(S,0,(1 << n) - 1) printf("%d ",dp[S].val());
//    printf("\n");

    per(pos,n - 1,0){
//        printf("pos=%d\n",pos);
        int s = pos + 1;
        rep(P,0,(1 << (n - pos - 1)) - 1){
            fill(A,A + (1 << s),0);fill(B,B + (1 << s),0);fill(C,C + (1 << s),0);
            rep(S,0,(1 << s) - 1){
                if((S >> pos) & 1){
                    A[(1 << s) - 1 - S] += dp[(P << s) | S];
                    if(__builtin_parity(S)) B[S] += _ret[S];
                }
            }
/*            printf("P=%d\n",P);
            rep(S,0,(1 << s) - 1) printf("%d ",A[S].val());
            printf("\n");
            rep(S,0,(1 << s) - 1) printf("%d ",B[S].val());
            printf("\n");*/
            conv(A,B,C,s);
//            rep(S,0,(1 << s) - 1) printf("%d ",C[S].val());
//            printf("\n");  
            rep(S,0,(1 << s) - 1){
                if((S >> pos) & 1) ndp[(P << s) + (1 << (pos + 1)) - 1 - S + (1 << pos)] += C[S];
                else ndp[(P << s) | S] += dp[(P << s) | S];
            }
        }
        rep(S,0,(1 << n) - 1){
            dp[S] = ndp[S];
            ndp[S] = 0;
//            printf("%d ",dp[S].val());
        }
//        printf("\n");
    }
/*    printf("final:\n");
    rep(S,0,(1 << n) - 1){
        rep(i,0,n - 1) printf("%d",(S >> i) & 1);
        printf(" %d\n",dp[S].val());
    }
    printf("\n");*/
    Z ans = 0;
    rep(S,0,(1 << n) - 1) ans += dp[S] * calc(S);
    printf("%d\n",ans.val());
	return 0;
}