#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
using LL = long long;
struct Edge{
int to;
int id;
operator int() const { return to; }
};
struct LowLink{
int n;
vector<vector<Edge> > g;
vector<int> in, out, low;
int ts;
// map<int, int> bridge;
LowLink(const vector<vector<Edge> > &g) : n(int(g.size()) - 1), g(g) {
ts = 0;
in.assign(n + 1, 0);
out.assign(n + 1, 0);
low.assign(n + 1, 0);
for(int i = 1; i <= n; i++){
if (in[i] == 0){
tarjan(i, -1);
}
}
id.assign(n + 1, 0);
cnt = 0;
for(int i = 1; i <= n; i++){
if (id[i] == 0){
dfs(i, -1);
}
}
group.resize(cnt + 1);;
for(int i = 1; i <= n; i++){
group[id[i]].push_back(i);
}
}
void tarjan(int u, int from){
in[u] = low[u] = ++ts;
for(auto j : g[u]){
if (!in[j]){
tarjan(j, j.id);
low[u] = min(low[u], low[j]);
// if (low[j] > in[u]){
// bridge[j.id] = j;
// }
}
else if (j.id != from) low[u] = min(low[u], in[j]);
}
out[u] = ts;
}
int cnt;
vector<vector<int> > group;
vector<int> id;
void dfs(int u, int fa){
if (fa != -1 && low[u] <= in[fa]){
id[u] = id[fa];
}
else{
id[u] = ++cnt;
}
for(auto j : g[u]){
if (id[j] == 0){
dfs(j, u);
}
}
}
};
struct HLD{
int n;
vector<int> sz, top, dep, fa, in, out, seq;
vector<vector<int> > g;
int ts;
HLD(const vector<vector<int> > &g, int root = 1) : n(int(g.size()) - 1), g(g) {
ts = 0;
sz.resize(n + 1);
top.resize(n + 1);
dep.resize(n + 1);
fa.resize(n + 1);
in.resize(n + 1);
out.resize(n + 1);
seq.resize(n + 1);
dep[root] = 1;
top[root] = root;
dfs_sz(root);
dfs_hld(root);
}
void dfs_sz(int u){
if (fa[u]){
for(auto it = g[u].begin(); it != g[u].end(); it++){
if (*it == fa[u]){
g[u].erase(it);
break;
}
}
}
sz[u] = 1;
for(auto &j : g[u]){
fa[j] = u;
dep[j] = dep[u] + 1;
dfs_sz(j);
sz[u] += sz[j];
if (sz[j] > sz[g[u][0]])
swap(j, g[u][0]);
}
}
void dfs_hld(int u){
in[u] = ++ts;
seq[in[u]] = u;
for (auto j : g[u]){
top[j] = (j == g[u][0] ? top[u] : j);
dfs_hld(j);
}
out[u] = ts;
}
int lca(int u, int v){
while (top[u] != top[v]){
if (dep[top[u]] > dep[top[v]]){
u = fa[top[u]];
}
else{
v = fa[top[v]];
}
}
return dep[u] < dep[v] ? u : v;
}
int dist(int u, int v){
return dep[u] + dep[v] - 2 * dep[lca(u, v)];
}
bool in_subtree(int u, int v){
return in[v] <= in[u] && in[u] <= out[v];
}
int jump(int u, int k) {
if (dep[u] < k){
return -1;
}
int d = dep[u] - k;
while (dep[top[u]] > d){
u = fa[top[u]];
}
return seq[in[u] - dep[u] + d];
}
int rooted_lca(int a, int b, int c){
return lca(a, b) ^ lca(b, c) ^ lca(c, a);
}
template<typename Q>
void modify_path(int u, int v, const Q &q, bool edge = false){
while(top[u] != top[v]){
if (dep[top[u]] < dep[top[v]]) swap(u, v);
q(in[top[u]], in[u]);
u = fa[top[u]];
}
if (dep[u] > dep[v]) swap(u, v);
q(in[u] + edge, in[v]);
}
template<typename Q>
void modify_subtree(int u, const Q &q){
q(in[u], out[u]);
}
template<typename T, typename Q>
T query_path(int u, int v, const Q &q, bool edge = false){
T ret = T();
while(top[u] != top[v]){
if (dep[top[u]] < dep[top[v]]) swap(u, v);
ret = q(in[top[u]], in[u]) + ret;
u = fa[top[u]];
}
if (dep[u] > dep[v]) swap(u, v);
return q(in[u] + edge, in[v]) + ret;
}
template<typename T, typename Q>
T query_subtree(int u, const Q &q){
return q(in[u], out[u]);
}
template<typename T, typename Q, typename F>
T query_path_noncommutative(int u, int v, const Q &q, const F &f, bool edge = false){
T left = T(), right = T();
while(top[u] != top[v]){
if (dep[top[u]] < dep[top[v]]) swap(u, v), swap(left, right);
left = q(in[top[u]], in[u]) + left;
u = fa[top[u]];
}
if (dep[u] > dep[v]) swap(u, v), swap(left, right);
return f(left, q(in[u] + edge, in[v]) + right);
}
pair<vector<int>, vector<pair<int, int> > > compress(vector<int> v){
auto cmp = [&](int a, int b) { return in[a] < in[b]; };
sort(v.begin(), v.end(), cmp);
v.erase(unique(v.begin(), v.end()), v.end());
const int k = (int)v.size();
for(int i = 0; i + 1 < k; i++){
v.push_back(lca(v[i], v[i + 1]));
}
sort(v.begin(), v.end(), cmp);
v.erase(unique(v.begin(), v.end()), v.end());
vector<pair<int, int> > edges;
vector<int> stk;
for(auto x : v){
while(!stk.empty() && out[stk.back()] < in[x]){
stk.pop_back();
}
if (!stk.empty()){
edges.push_back({stk.back(), x});
}
stk.push_back(x);
}
return {v, edges};
}
};
int main(){
#ifdef LOCAL
freopen("data.in", "r", stdin);
freopen("data.out", "w", stdout);
#endif
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
int T;
cin >> T;
while(T--){
int n, m;
cin >> n >> m;
vector<vector<Edge> > g(n + 1);
for(int i = 0; i < m; i++){
int a, b;
cin >> a >> b;
g[a].push_back({b, i});
g[b].push_back({a, i});
}
vector<int> cnt(n + 1);
for(int i = 1; i <= n; i++){
int x;
cin >> x;
cnt[x] += 1;
}
vector<int> nums;
vector<int> id(n + 1);
for(int i = 1; i <= n; i++){
if (cnt[i]){
nums.push_back(i);
id[nums.size()] = i;
}
}
if (nums.size() == 1){
cout << "Yes" << '\n';
for(int i = 1; i <= n; i++){
cout << nums[0] << " \n"[i == n];
}
continue;
}
LowLink lk(g);
const int s = (int)lk.group.size() - 1;
vector<vector<int> > ng(s + 1);
vector<int> sz(s + 1);
for(int i = 1; i <= n; i++){
for(auto [j, id] : g[i]){
if (lk.id[i] != lk.id[j]){
ng[lk.id[i]].push_back(lk.id[j]);
}
}
}
HLD hld(ng);
vector<int> dp1(s + 1), dp2(s + 1);
vector<int> pre1(s + 1), pre2(s + 1);
vector<int> target1(n + 1), target2(n + 1);
vector<vector<int> > pos1(nums.size() + 1);
vector<vector<int> > pos2(nums.size() + 1);
{
int sum = 0;
for(int i = 0; i < nums.size(); i++){
sum += cnt[nums[i]];
target1[i + 1] = sum;
}
auto dfs = [&](auto &&dfs, int u, int fa) -> void {
sz[u] = lk.group[u].size();
for(auto j : ng[u]){
if (j == fa) continue;
dfs(dfs, j, u);
sz[u] += sz[j];
if (dp1[j] > dp1[u]){
dp1[u] = dp1[j];
pre1[u] = j;
}
}
if (target1[dp1[u] + 1] == sz[u]){
dp1[u] += 1;
pos1[dp1[u]].push_back(u);
}
};
dfs(dfs, 1, -1);
}
{
int sum = 0;
reverse(nums.begin(), nums.end());
for(int i = 0; i < nums.size(); i++){
sum += cnt[nums[i]];
target2[i + 1] = sum;
}
reverse(nums.begin(), nums.end());
auto dfs = [&](auto &&dfs, int u, int fa) -> void {
sz[u] = lk.group[u].size();
for(auto j : ng[u]){
if (j == fa) continue;
dfs(dfs, j, u);
sz[u] += sz[j];
if (dp2[j] > dp2[u]){
dp2[u] = dp2[j];
pre2[u] = j;
}
}
if (target2[dp2[u] + 1] == sz[u]){
dp2[u] += 1;
pos2[dp2[u]].push_back(u);
}
};
dfs(dfs, 1, -1);
}
vector<int> ans(s + 1);
vector<int> path;
auto get_path = [&](int p, int k, vector<int> &target, vector<int> &pre){
vector<int> path;
path.push_back(hld.fa[p]);
ans[hld.fa[p]] = nums[k];
path.push_back(p);
int cur = k;
ans[p] = nums[cur - 1];
while(cur != 1){
p = pre1[p];
if (target[cur - 1] == sz[p]){
cur -= 1;
}
ans[p] = nums[cur - 1];
path.push_back(p);
}
return path;
};
if (!pos1[nums.size() - 1].empty()){
int p = pos1[nums.size() - 1][0];
path = get_path(p, (int)nums.size() - 1, target1, pre1);
}
else if (!pos2[nums.size() - 1].empty()){
reverse(nums.begin(), nums.end());
int p = pos2[nums.size() - 1][0];
path = get_path(p, nums.size() - 1, target2, pre2);
}
else{
for(int i = 1; i <= nums.size(); i++){
sort(pos1[i].begin(), pos1[i].end(), [&](int a, int b){
return hld.in[a] < hld.in[b];
});
sort(pos2[i].begin(), pos2[i].end(), [&](int a, int b){
return hld.in[a] < hld.in[b];
});
}
for(int i = 1; i + 1 <= nums.size(); i++){
if (!path.empty()) break;
auto &v = pos2[nums.size() - 1 - i];
if (v.empty() || pos1[i].empty()) continue;
for(auto x : pos1[i]){
if (!path.empty()) break;
if (hld.in[v.back()] > hld.out[x]){
int p1 = x, p2 = v.back();
path = get_path(p1, i, target1, pre1);
reverse(nums.begin(), nums.end());
auto path2 = get_path(p2, (int)nums.size() - i - 1, target2, pre2);
path.insert(path.end(), path2.begin(), path2.end());
}
}
}
for(int i = 1; i + 1 <= nums.size(); i++){
if (!path.empty()) break;
auto &v = pos1[nums.size() - 1 - i];
if (v.empty() || pos2[i].empty()) continue;
for(auto x : pos2[i]){
if (!path.empty()) break;
if (hld.in[v.back()] > hld.out[x]){
int p1 = x, p2 = v.back();
path = get_path(p1, i, target1, pre1);
reverse(nums.begin(), nums.end());
auto path2 = get_path(p2, (int)nums.size() - i - 1, target2, pre2);
path.insert(path.end(), path2.begin(), path2.end());
}
}
}
}
if (path.empty()){
cout << "No" << '\n';
}
else{
auto dfs = [&](auto &&dfs, int u) -> void {
for(auto j : ng[u]){
if (!ans[j]){
ans[j] = ans[u];
dfs(dfs, j);
}
}
};
for(auto x : path){
dfs(dfs, x);
}
cout << "Yes" << '\n';
for(int i = 1; i <= n; i++){
cout << ans[lk.id[i]] << " \n"[i == n];
}
}
}
}