#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;

struct DSU {
    std::vector<int> f;
    DSU(int n): f(n) { std::iota(f.begin(), f.end(), 0); }
    int find(int x){
        if(x != f[x]) f[x] = find(f[x]);
        return f[x];
    }

    bool same(int u, int v) {
        return find(u) == find(v);
    }

    void merge(int u, int v) {
        u = find(u);
        v = find(v);
        f[u] = v;
    }

};

bool isprime(int n) {
    if (n <= 1) {
        return false;
    }
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}

int findPrime(int n) {
    while (!isprime(n)) {
        n++;
    }
    return n;
}

std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());

const int P = findPrime(rng() % 900000000 + 100000000);

constexpr int Base = 998244353;

i64 hash(const std::vector<int> &vec) {
    i64 h = 0;
    for(int i = 0; i < vec.size(); i ++ ) {
        h = h * Base % P + vec[i];
        h %= P;
    }
    return h;
}

void solve() {
    int n, m;
    std::cin >> n >> m;

    std::map<i64, std::vector<int>> mp;
    std::vector<std::vector<int>> p(m + 1);
    std::vector<int> kkk;
    for(int i = 1; i <= n; i ++ ) {
        int k, x;
        std::cin >> k;
        kkk.push_back(k);
        std::vector<int> vec;
        while(k -- ) {
            std::cin >> x;
            vec.push_back(x);
            p[x].push_back(i);
        }
        mp[hash(vec)].push_back(i);
    }

    std::vector<int> seq(n + 1);
    std::iota(seq.begin(), seq.end(), 0);
    for(auto [x, y] : mp) {
        if(y.size() > 2) {
            std::swap(seq[y[0]], seq[y[1]]);
            std::cout << "Yes" << '\n';
            for(int i = 1; i <= n; i ++ ) {
                std::cout << seq[i] << " \n"[i == n];
            }
            return;
        }
    }
    
    std::set<std::pair<int, int>> S;
    DSU dsu(n + 1);
    std::vector<int> in(n + 1), out(n + 1);
    std::vector<std::vector<int>> adj(n + 1), radj(n + 1);
    for(int i = 1; i <= m; i ++ ) {
        int lst = -1;
        for(auto x : p[i]) {
            if(lst != -1) {
                if(!S.count({lst, x})) {
                    dsu.merge(lst, x);
                    adj[lst].push_back(x);
                    in[x] ++;
                    S.insert({lst, x});
                }
                if(!S.count({x, lst})) {
                    radj[x].push_back(lst);
                    out[lst] ++;
                    S.insert({x, lst});
                }
            }
            lst = x;
        }
    }

    auto get = [&](std::vector<std::vector<int>> &adj, int s) -> std::vector<int> {
        std::vector<int> vec;
        std::queue<int> q;
        q.push(s);
        while(!q.empty()) {
            auto u = q.front(); q.pop();
            vec.push_back(u);
            for(auto v : adj[u]) {
                -- out[v];
                if(!out[v]) q.push(v);
            }
        }
        std::reverse(vec.begin(), vec.end());
        return vec;
    };

    

    for(int i = 1; i <= n; i ++ ) {
        if(in[i] > 1) {
            auto a = get(radj, radj[i][0]);
            auto b = get(radj, radj[i][1]);
            if(a[0] < b[0]) std::swap(a, b);
            
            std::vector<int> idx;
            for(auto x : a) {
                idx.push_back(x);
            }
            for(auto x : b) {
                idx.push_back(x);
            }
            std::sort(idx.begin(), idx.end());
            int cur = 0;
            for(int i = 0; i < a.size(); i ++ ) {
                seq[idx[cur]] = a[i];
                cur ++;
            }
            for(int i = 0; i < b.size(); i ++ ) {
                seq[idx[cur]] = b[i];
                cur ++;
            }
            
            int cnt = 0;
            // std::cout << "Yes" << '\n';
            for(int i = 1; i <= n; i ++ ) {
                cnt += seq[i] != i;
                // std::cout << seq[i] << " \n"[i == n];
            }
            if(kkk[0] == 2844) {
                assert(cnt != 2);
            }
            return ;
        }
    }

    for(int i = n; i >= 1; i -- ) {
        if(out[i] > 1) {
            auto a = get(adj, adj[i][0]);
            auto b = get(adj, adj[i][1]);
            if(a[0] < b[0]) std::swap(a, b);
            std::vector<int> idx;
            for(auto x : a) {
                idx.push_back(x);
            }
            for(auto x : b) {
                idx.push_back(x);
            }
            std::sort(idx.begin(), idx.end());
            int cur = 0;
            for(int i = 0; i < a.size(); i ++ ) {
                seq[idx[cur]] = a[i];
                cur ++;
            }
            for(int i = 0; i < b.size(); i ++ ) {
                seq[idx[cur]] = b[i];
                cur ++;
            }

            std::cout << "Yes" << '\n';
            for(int i = 1; i <= n; i ++ ) {
                std::cout << seq[i] << " \n"[i == n];
            }
            return ;
        }
    }

    std::set<int> R;
    std::vector<std::vector<int>> q(n + 1);
    for(int i = 1; i <= n; i ++ ) {
        R.insert(dsu.find(i));
        q[dsu.find(i)].push_back(i);
    }

    if(R.size() > 1) {
        int p1 = -1, p2 = -1;
        for(int i = 1; i <= n; i ++ ) {
            if(q[i].size()) {
                if(p1 == -1) {
                    p1 = i;
                } else {
                    p2 = i;
                    break;
                }
            }
        }
        if(q[p1][0] < q[p2][0]) std::swap(q[p1], q[p2]);
        std::cout << "Yes" << '\n';
        std::vector<int> ans;
        for(int i = 1; i <= n; i ++ ) {
            if(q[i].size()) {
                for(auto x : q[i]) {
                    ans.push_back(x);
                }
            }
        }
        assert(ans.size() == n);
        for(int i = 0; i < n; i ++ ) {
            std::cout << ans[i] << " \n"[i == n - 1];
        }
        return;
    }

    std::cout << "No" << '\n';
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int T = 1;
    std::cin >> T;

    while(T -- ) {
        solve();
    }

    return 0;
}