#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
#define ov4(a, b, c, d, name, ...) name
#define rep3(i, a, b, c) for(ll i = (a); i < (b); i += (c))
#define rep2(i, a, b) rep3(i, a, b, 1)
#define rep1(i, n) rep2(i, 0, n)
#define rep0(n) rep1(aaaaa, n)
#define rep(...) ov4(__VA_ARGS__, rep3, rep2, rep1, rep0)(__VA_ARGS__)
#define per(i, a, b) for(ll i = (a)-1; i >= (b); i--)
#define fore(e, v) for(auto&& e : v)
#define all(a) begin(a), end(a)
#define si(a) (int)(size(a))
#define lb(v, x) (lower_bound(all(v), x) - begin(v))
#define eb emplace_back

template<typename T, typename S> bool chmin(T& a, const S& b) { return a > b ? a = b, 1 : 0; }
template<typename T, typename S> bool chmax(T& a, const S& b) { return a < b ? a = b, 1 : 0; }

const int INF = 1e9 + 100;
const ll INFL = 3e18 + 100;

#define i128 __int128_t
constexpr int mod = 998244353;
struct mint {
   int x;
   mint(ll x_ = 0) : x(x_ % mod) {
      if(x < 0) x += mod;
   }
   mint operator-() {
      auto res = *this;
      res.x = (x ? mod - x : 0);
      return res;
   }
   mint& operator+=(mint r) {
      if((x += r.x) >= mod) x -= mod;
      return *this;
   }
   mint& operator-=(mint r) {
      if((x -= r.x) < 0) x += mod;
      return *this;
   }
   mint& operator*=(mint r) {
      x = 1LL * x * r.x % mod;
      return *this;
   }
   mint& operator/=(mint r) { return *this *= r.inv(); }
   friend mint operator+(mint a, mint b) { return a += b; }
   friend mint operator-(mint a, mint b) { return a -= b; }
   friend mint operator*(mint a, mint b) { return a *= b; }
   friend mint operator/(mint a, mint b) { return a /= b; }
   mint inv() const { return pow(mod - 2); }
   mint pow(ll b) const {
      mint a = *this, c = 1;
      while(b) {
         if(b & 1) c *= a;
         a *= a;
         b >>= 1;
      }
      return c;
   }
};
/*
aaaaa
aaaaa
aaaaa
aaaaa
aaaaa
*/
using vm = vector<mint>;

struct UnionFind {
   vector<int> data;
   UnionFind(int N) : data(N, -1) {}

   int find(int k) { return data[k] < 0 ? k : data[k] = find(data[k]); }

   int merge(int x, int y) {
      if((x = find(x)) == (y = find(y))) return false;
      if(data[x] > data[y]) swap(x, y);
      data[x] += data[y];
      data[y] = x;
      return true;
   }

   int size(int k) { return -data[find(k)]; }

   int same(int x, int y) { return find(x) == find(y); }
};

void solve(){
    ll n,m,k;
    cin >> n >> m >> k;
    vector<vl> edge(n);
    vector<vl> edge2(n);
    vector<pll> e;
    rep(i,m){
        ll u,v;
        cin >> u >> v;
        u--;
        v--;
        e.emplace_back(u,v);
        edge2[u].push_back(v);
        edge2[v].push_back(u);
        
    }

    UnionFind uf(n);
    for(auto [u,v]:e){
        if(uf.same(u,v) == false){
            uf.merge(u,v);
            edge[u].push_back(v);
            edge[v].push_back(u);

        }
    }

    bool is_bi = true;

    vl dist(n,-1);
    queue<ll> q;
    q.emplace(0);
    dist[0] = 0;
    while(!q.empty()){
        auto now = q.front();
        q.pop();
        for(ll to:edge2[now]){
            if(dist[to] == -1){
                dist[to] = dist[now] ^ 1;
                q.emplace(to);
            }
            else if(dist[to] == dist[now]){
                is_bi = false;
            }
        }
    }

    vl b(n);
    rep(i,n){
        cin >> b[i];
    }

    vl a(n,0);


    auto dfs = [&](auto dfs,ll now,ll p) -> void {
        for(ll to:edge[now]){
            if(to == p){continue;}
            dfs(dfs,to,now);
        }
        if(now == 0){return;}
        ll z = (b[now] - a[now] + k) % k;
        a[now] += z;
        a[now] %= k;
        a[p] += z;
        a[p] %= k;
    };
    dfs(dfs,0,-1);
    string ans = "No";

    if(is_bi){
        if(a == b){
            ans = "Yes";
        }
        else{
            ans = "No";
        }
    }
    else{
        if((k % 2 == 0 && a[0] % 2 == b[0] % 2) || (k % 2 == 1)){
            ans = "Yes";
        }
        else{
            ans = "No";
        }
    }
    cout << ans << endl;
}


int main() { 
    cin.tie(0)->sync_with_stdio(0); 

    ll t;
    cin >> t;
    rep(i,t){
        solve();
    }
    

    
}