#include <bits/stdc++.h>
using namespace std;

using LL = long long;
const int N = 2e4 + 5;
const int P = 1e9 + 7;

inline LL qp(LL a, LL b = P - 2) {
  LL c = 1;
  while (b) {
    if (b & 1) (c *= a) %= P;
    (a *= a) %= P;
    b /= 2;
  }
  return c;
}

LL inv[N], fac[N], ifac[N];
void init() {
  fac[0] = 1;
  for (int i = 1; i < N; ++i) {
    inv[i] = qp(i);
    fac[i] = fac[i - 1] * i % P;
  }
  ifac[N - 1] = qp(fac[N - 1]);
  for (int i = N - 1; i > 0; --i) {
    ifac[i - 1] = ifac[i] * i % P;
  }
}

int n, m, cnt;
LL p[N], q[N];
vector<int> G[N], E[N];

int ti, low[N], dfn[N];
vector<int> stk;

void tarjan(int u, int fa) {
  low[u] = dfn[u] = ++ti;
  stk.push_back(u);
  for (auto v : G[u]) if (v != fa) {
    if (!dfn[v]) {
      tarjan(v, u);
      low[u] = min(low[u], low[v]);
      if (dfn[u] <= low[v]) {
        if (dfn[v] == low[v]) {
          E[u].emplace_back(v);
          stk.pop_back();
        } else {
          int o = ++cnt;
          while (stk.back() != v) {
            E[o].emplace_back(stk.back());
            stk.pop_back();
          }
          E[o].emplace_back(stk.back());
          stk.pop_back();
          E[u].emplace_back(o);
        }
      }
    } else {
      low[u] = min(low[u], dfn[v]);
    }
  }
}

LL f[N], g[N], vis[N];
vector<LL> h[N], pw[N];

void dp1(int u) {
  if (u > n) {
    LL r = 1;
    for (auto v : E[u]) {
      dp1(v);
      LL rs = 0;
      for (int i = 0; i < h[v].size(); ++i) if (h[v][i]) {
        (rs += pw[v][i + 1] * fac[i] % P * h[v][i] % P
            * inv[G[v].size() - 1 - 2 * i] % P) %= P;
      }
      (r *= rs) %= P;
    }
    (f[u] += r * 2) %= P;
  } else {
    int cir = 0;
    for (auto v : E[u]) cir += v > n;
    pw[u].resize(cir + 2);
    pw[u][0] = 1;
    for (int i = 1; i <= cir + 1; ++i) {
      pw[u][i] = pw[u][i - 1] * q[u] % P;
    }
    h[u].resize(cir + 1);
    h[u][0] = 1;
    for (auto v : E[u]) {
      dp1(v);
      if (v <= n) continue;
      for (int i = cir; i >= 0; --i) if (h[u][i]) {
        (h[u][i + 1] += h[u][i] * f[v] % P
            * inv[G[u].size() - (u != 1) - 2 * i] % P) %= P;
      }
    }
  }
}

void dp2(int u) {
  if (u <= n) {
    for (int i = 0; i < h[u].size(); ++i) if (h[u][i]) {
      (g[u] += vis[u] * pw[u][i] % P * fac[i] % P * h[u][i] % P
          * (2 * i == G[u].size() - (u != 1) ? 1 : p[u]) % P) %= P;
    }
    for (auto v : E[u]) {
      if (v > n) {
        for (int i = 0; i + 1 < h[u].size(); ++i) {
          (h[u][i + 1] += P - h[u][i] * f[v] % P
              * inv[G[u].size() - (u != 1) - 2 * i] % P) %= P;
        }
      }
      LL &r = vis[v];
      for (int i = 0; i < h[u].size(); ++i) if (h[u][i]) {
        (r += vis[u] * pw[u][i + 1] % P * fac[i] % P * h[u][i] % P
            * inv[G[u].size() - (u != 1) - 2 * i] % P) %= P;
      }
      dp2(v);
      if (v > n) {
        for (int i = int(h[u].size()) - 1; i >= 0; --i) if (h[u][i]) {
          (h[u][i + 1] += h[u][i] * f[v] % P
              * inv[G[u].size() - (u != 1) - 2 * i] % P) %= P;
        }
      }
    }
  } else {
    auto work = [&]() {
      LL r = vis[u];
      for (auto v : E[u]) {
        (vis[v] += r) %= P;
        LL rs = 0;
        for (int i = 0; i < h[v].size(); ++i) if (h[v][i]) {
          (rs += pw[v][i + 1] * fac[i] % P * h[v][i] % P
              * inv[G[v].size() - 1 - 2 * i] % P) %= P;
        }
        (r *= rs) %= P;
      }
    };
    work();
    reverse(E[u].begin(), E[u].end());
    work();
    for (auto v : E[u]) dp2(v);
  }
}

void solve() {
  cin >> n >> m;
  cnt = n;
  for (int i = 1; i <= n; ++i) {
    cin >> p[i];
    q[i] = (1 + P - p[i]) % P;
  }
  for (int i = 1; i <= n; ++i)
    G[i].clear();
  for (int i = 1; i <= m; ++i) {
    int u, v;
    cin >> u >> v;
    G[u].emplace_back(v);
    G[v].emplace_back(u);
  }
  {
    ti = 0;
    stk.clear();
    for (int i = 1; i <= 2 * n; ++i) {
      low[i] = dfn[i] = 0;
      f[i] = g[i] = vis[i] = 0;
      h[i].clear();
      pw[i].clear();
      E[i].clear();
    }
  }
  tarjan(1, 0);
  dp1(1);
  vis[1] = 1;
  dp2(1);
  for (int i = 1; i <= n; ++i)
    cout << g[i] << " \n"[i == n];
}

int main() {
  cin.tie(0)->sync_with_stdio(0);
  init();
  int t;
  cin >> t;
  while (t--)
    solve();
  return 0;
}