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

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

vector<vector<int>> grafo;
vector<pair<int,int>> edges;

vi num, st; vector<vector<pii>> ed; int Time;
template<class F> int dfs(int at, int par, F& f) {
    int me = num[at] = ++Time, e, y, top = me;
    for (auto pa : ed[at]) if (pa.second != par) {
        tie(y, e) = pa;
        if (num[y]) {
            top = min(top, num[y]);
            if (num[y] < me)
                st.push_back(e);
        } else {
            int si = sz(st); int up = dfs(y, e, f);
            top = min(top, up);
            if (up == me) {
                st.push_back(e);
                f(vi(st.begin() + si, st.end()));
                st.resize(si);
            }
            else if (up < me) st.push_back(e);
            else{
                grafo[edges[e].first].push_back(edges[e].second);
                grafo[edges[e].second].push_back(edges[e].first);
            }
        }
    }
    return top;//idea per block cut tree: collego ogni
} //nodo con un nodo che rappresenta la sua bicomp.
template<class F> void bicomps(F f) { //0-based
    num.assign(sz(ed), 0);
    rep(i,0,sz(ed)) if (!num[i]) dfs(i, -1, f);
}

void solve(){
    int n,m;
    cin>>n>>m;
    if(n==0 && m==0)exit(0);
    
    grafo = vector(n,vector<int>());
    edges.clear();
    ed.clear();
    num.clear();st.clear();Time=0;
    
    int eid = 0;
    ed.resize(n);
    for(int i=0;i<m;i++){
        int s;
        cin>>s;
        int u;
        cin>>u;
        u--;
        for(int j=0;j<s-1;j++){
            int v;
            cin>>v;
            v--;
            edges.push_back({u,v});
            ed[u].emplace_back(v,eid);
            ed[v].emplace_back(u,eid++);
            u=v;
        }
    }
    
    
    int cc = 0;
    bicomps([&](const vi& edgelist){
        grafo.push_back(vector<int>());
        unordered_set<int> ds;
        for(auto i : edgelist){
            auto [u,v] = edges[i];
            ds.insert(u);
            ds.insert(v);
        }
        
        for(auto i : ds){
            grafo[n+cc].push_back(i);
            grafo[i].push_back(n+cc);
        }
        cc++;
    });
    
    if(cc<=1){
        cout<<"Yes\n";
    }else{
        
        vector grafo2(n+cc,vector<int>());
        
        auto dfs = [&](auto &dfs,int nodo,int last)->bool{
            bool res=(nodo>=n);
            for(auto i : grafo[nodo]){
                if(i!=last){
                    if(dfs(dfs,i,nodo)){
                        res=true;
                        grafo2[nodo].push_back(i);
                        grafo2[i].push_back(nodo);
                    }
                }
            }
            
            return res;
        };
        
        dfs(dfs,n,-1);
        
        int centro = -1;
        bool ok = true;
        for(int i=0;i<n;i++){
            
            for(auto j : grafo2[i]){
                if(grafo2[j].size()==1)continue;
                else{
                    if(centro==-1)centro=j;
                    else{
                        if(centro!=j){
                            ok=false;
                        }
                    }
                }
            }
        }
        
        if(ok){
            cout<<"Yes\n";
            return;
        }
        
        for(int i=0;i<n+cc;i++){
            int cont=0;
            
            for(auto j : grafo2[i]){
                if(grafo2[j].size()>1)cont++;
            }
            
            if(cont>2){
                cout<<"No\n";
                return;
            }
        }
        
        cout<<"Yes\n";
    }
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    //cin>>t;
    while(true)solve();
    
    return 0;
}