#include <bits/stdc++.h>

const int N = 100100;
const int mod = 1e9 + 7;

void add(int &x, const int &y) {
    x += y;
    if (x >= mod) x -= mod;
}

void dec(int &x, const int &y) {
    x -= y;
    if (x < 0) x += mod;
}

int qpow(int a, int b, int p) {
    int ans = 1;
    for (; b; b >>= 1) {
        if (b & 1) ans = 1ll * ans * a % p;
        a = 1ll * a * a % p;
    }
    return ans;
}

int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

int n, m, c;
int a[1 << 20], b[1 << 20];

void FWT_xor(int *a, const int &n, const int &opt) {
    for (int k = 1; k < n; k <<= 1)
        for (int i = 0; i < n; i += (k << 1))
            for (int j = 0; j < k; j ++) {
                int u = a[i + j], v = a[i + j + k];
                add(a[i + j] = u, v), dec(a[i + j + k] = u, v);
            }

    if (opt == -1) {
        int inv = qpow(n, mod - 2, mod);
        for (int i = 0; i < n; i ++) a[i] = 1ll * a[i] * inv % mod;
    }
}

int col[N];

int tot, head[N], ver[N * 2], Next[N * 2];
void add_edge(int u, int v) {
    ver[++ tot] = v;    Next[tot] = head[u];    head[u] = tot;
}

int Fa[N];
int dep[N];
int sze[N];
int son[N];

void dfs1(int u) {
    dep[u] = dep[Fa[u]] + 1;
    sze[u] = 1;

    for (int i = head[u]; i; i = Next[i]) {
        int v = ver[i];
        if (v == Fa[u]) continue;

        Fa[v] = u;
        dfs1(v);

        sze[u] += sze[v];
        if (sze[v] > sze[son[u]]) son[u] = v;
    }
}

int dfsClock, dfn[N], idx[N];
int chain_top[N];

void dfs2(int u, int P) {
    dfsClock ++;
    dfn[u] = dfsClock, idx[dfsClock] = u;

    chain_top[u] = P;

    if (son[u]) dfs2(son[u], P);
    for (int i = head[u]; i; i = Next[i]) {
        int v = ver[i];
        if (v == Fa[u] || v == son[u]) continue;

        dfs2(v, v);
    }
}

namespace SGT {
    struct node {
        int l, r;
        int sum;
    } t[N * 4];

    void upd(int p) {
        t[p].sum = t[p * 2].sum ^ t[p * 2 + 1].sum;
    }

    void build(int p, int l, int r) {
        t[p].l = l, t[p].r = r;
        if (l == r) {
            t[p].sum = (1 << col[idx[l]]);
            return;
        }
        int mid = (t[p].l + t[p].r) >> 1;
        build(p * 2, l, mid), build(p * 2 + 1, mid + 1, r);
        upd(p);
    }

    void change(int p, int x) {
        if (t[p].l == t[p].r) {
            t[p].sum = (1 << col[idx[x]]);
            return;
        }
        int mid = (t[p].l + t[p].r) >> 1;
        if (x <= mid)
            change(p * 2, x);
        else
            change(p * 2 + 1, x);
        upd(p);
    }

    int ask(int p, int l, int r) {
        if (l <= t[p].l && t[p].r <= r)
            return t[p].sum;
        int mid = (t[p].l + t[p].r) >> 1;
        if (l <= mid && mid < r)
            return ask(p * 2, l, r) ^ ask(p * 2 + 1, l, r);
        if (l <= mid)
            return ask(p * 2, l, r);
        else
            return ask(p * 2 + 1, l, r);
    }
}

int path_ask(int x, int y) {
    int ans = 0;
    while (chain_top[x] ^ chain_top[y]) {
        if (dep[chain_top[x]] > dep[chain_top[y]]) std::swap(x, y);
        ans ^= SGT::ask(1, dfn[chain_top[y]], dfn[y]);
        y = Fa[chain_top[y]];
    }
    if (dep[x] > dep[y]) std::swap(x, y);
    ans ^= SGT::ask(1, dfn[x], dfn[y]);
    return ans;
}

int main() {
    scanf("%d%d%d", &m, &c, &n);

    for (int i = 0; i < c; i ++) scanf("%d", &b[1 << i]);

    b[0] = 0;
    for (int S = 1; S < (1 << c); S ++) b[S] = gcd(b[S ^ (S & -S)], b[S & -S]);

    for (int i = 1; i <= m; i ++) {
        int S = 0, cnt = 0;

        scanf("%d", &cnt);
        for (int j = 1, x; j <= cnt; j ++) {
            scanf("%d", &x);
            S |= (1 << x);
        }

        a[S] ++;
    }

    FWT_xor(a, 1 << c, +1), FWT_xor(b, 1 << c, +1);
    for (int i = 0; i < (1 << c); i ++) a[i] = 1ll * a[i] * b[i] % mod;
    FWT_xor(a, 1 << c, -1);

    for (int i = 1; i <= n; i ++) scanf("%d", &col[i]);

    for (int i = 1, u, v; i < n; i ++) {
        scanf("%d%d", &u, &v), u ++, v ++;
        add_edge(u, v), add_edge(v, u);
    }

    dfs1(1);
    dfs2(1, 1);

    SGT::build(1, 1, n);

    int cur = 0;
    for (int i = 1, u, v, w, y; i <= m; i ++) {
        scanf("%d%d%d%d", &u, &v, &w, &y), u ++, v ++, w ++;

        cur ^= path_ask(u, v);
        printf("%d\n", a[cur]);

        col[w] = y, SGT::change(1, dfn[w]);
    }

    puts("");

    return 0;
}