#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC target("avx")
#include <bits/stdc++.h>
#define re register
#define ull unsigned long long
using namespace std;
inline int read() {
    re int t = 0;
    re char v = getchar();

    while (v < '0')
        v = getchar();

    while (v >= '0')
        t = (t << 3) + (t << 1) + v - 48, v = getchar();

    return t;
}
const int M = 998244353;
inline int ksm(re int x, re int y) {
    re int s = 1;

    while (y) {
        if (y & 1)
            s = 1ll * s * x % M;

        x = 1ll * x * x % M, y >>= 1;
    }

    return s;
}
int n, f[22][1 << 21], g[22][1 << 21], fa[22], N, m, p, X[402], Y[402], L[1 << 21], d[22], popcnt[1 << 21],
    b[1 << 21], W[22], sum[1 << 21], inv[1 << 21], I[4000002], G[22][22], O[22], nn;
ull A[1 << 21], lmt = 17e18;
inline void add(re int &x, re int y) {
    (x += y) >= M ? x -= M : x;
}
inline void Add(re ull &x, re ull y) {
    (x += y) >= lmt ? x %= M : x;
}
inline int root(re int x) {
    return x == fa[x] ? x : fa[x] = root(fa[x]);
}
inline void FWT(re int *f) {
    for (re int i = 1; i < N; i <<= 1)
        for (re int j = 0; j < N; j += i << 1)
            for (re int k = 0; k < i; ++k)
                add(f[j + k + i], f[j + k]);
}
inline void IFWT(re int *f) {
    for (re int i = 1; i < N; i <<= 1)
        for (re int j = 0; j < N; j += i << 1)
            for (re int k = 0; k < i; ++k)
                add(f[j + k + i], M - f[j + k]);
}
int main() {
    n = read(), m = read(), p = read(), N = 1 << n, I[0] = I[1] = 1;

    for (re int i = 2; i <= 4000000; ++i)
        I[i] = 1ll * I[M % i] * (M - M / i) % M;

    for (re int i = 1; i <= m; ++i)
        X[i] = read() - 1, Y[i] = read() - 1, G[X[i]][Y[i]] = G[Y[i]][X[i]] = 1;

    for (re int i = 0; i < n; ++i)
        W[i] = read();

    for (re int i = 0; i < N; ++i) {
        popcnt[i] = popcnt[i >> 1] + (i & 1);
        re int s = 0, w = 0;
        nn = 0;

        for (re int j = 0; j < n; ++j)
            if (i & (1 << j))
                add(w, W[j]), O[++nn] = j;

        for (re int j = 1; j <= nn; ++j)
            fa[j] = j, d[j] = 0;

        for (re int x = 1; x <= nn; ++x)
            for (re int y = x + 1; y <= nn; ++y)
                if (G[O[x]][O[y]]) {
                    ++d[x], ++d[y];

                    if (root(x)^root(y))
                        ++s, fa[root(x)] = root(y);
                }

        if (s != popcnt[i] - 1)
            b[i] = 1;

        for (re int j = 1; j <= nn; ++j)
            if (d[j] & 1)
                b[i] = 1;

        w = ksm(w, p);

        if (b[i])
            g[popcnt[i]][i] = w;

        sum[i] = w, inv[i] = I[w];
    }

    f[0][0] = 1, FWT(f[0]);

    for (re int i = 1; i <= n; ++i)
        FWT(g[i]);

    for (re int i = 1; i <= n; ++i) {
        for (re int j = 0; j < i; ++j)
            for (re int k = 0; k < N; ++k)
                Add(A[k], 1ll * f[j][k]*g[i - j][k]);

        for (re int k = 0; k < N; ++k)
            f[i][k] = A[k] >= M ? A[k] % M : A[k], A[k] = 0;

        IFWT(f[i]);

        for (re int k = 0; k < N; ++k)
            if (popcnt[k] == i && p)
                f[i][k] = 1ll * f[i][k] * inv[k] % M;
            else if (popcnt[k]^i)
                f[i][k] = 0;

        if (i ^ n)
            FWT(f[i]);
    }

    printf("%d", f[n][(1 << n) - 1]);
}