#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<cassert>
#include<map>
#include<queue>
#include<string>
#include<cstring>
#include<set>

#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define inf (1<<29)
#define all(n) (n).begin(),(n).end()
#define MAX_V 1100

using namespace std;

//follow
struct edge
{
  int to,cap,rev;
  edge(int to=inf,int cap=inf,int rev=inf):to(to),cap(cap),rev(rev){}
};

vector<edge> G[MAX_V];
int level[MAX_V];
int iter[MAX_V];
bool used[MAX_V];

void init(int V)
{
  rep(i,V)G[i].clear();
}

void add_edge(int from,int to,int cap)
{
  G[from].push_back(edge(to,cap,G[to].size()));
  G[to].push_back(edge(from,0,G[from].size()-1));
}
/*
void bfs(int s)
{
  memset(level,-1,sizeof(level));
  queue<int> que;
  level[s] = 0;
  que.push(s);
  while(!que.empty())
    {
      int v = que.front(); que.pop();
      for(int i=0;i<G[v].size();i++)
	{
	  edge &e = G[v][i];
	  if(e.cap > 0 && level[e.to] < 0)
	    {
	      level[e.to] = level[v] + 1;
	      que.push(e.to);
	    }
	}
    }
}
*/
int dfs(int v,int t,int f)
{
  if(v == t)return f;
  used[v] = true;
  for(int i=0;i<G[v].size();i++)
    {
      edge &e = G[v][i];
      if(e.cap > 0 && !used[e.to])
	{
	  int d = dfs(e.to,t,min(f,e.cap));
	  if(d > 0)
	    {
	      e.cap -= d;
	      G[e.to][e.rev].cap += d;
	      return d;
	    }
	}
    }
  return 0;
}

int max_flow(int s,int t)
{
  int flow = 0;
  for(;;)
    {
      memset(used,0,sizeof(used));
      int f = dfs(s,t,inf);
      if(f == 0)
	{
	  return flow;
	}
      flow += f;
    }
}


//

int main()
{
  int N;
  while(cin >> N,N)
    {
      int k,day,V,s,t;
      cin >> k;

      V = 2 + k + N;
      s = k + N;
      t = s + 1;
      init(V);
      map<int,int> days;
      vector<int> vday;
      rep(i,k)
	{
	  cin >> day;
	  vday.push_back(day);
	  add_edge(s,i,1);
	}
      sort(all(vday));
      rep(i,k)
	{
days[vday[i]] = i;
	}

      int index = k;
      int K = k;

      rep(i,N)
	{
	  cin >> k;
	  rep(j,k)
	    {
	      cin >> day;
	      if(days.find(day) != days.end())
		{
		  add_edge(days[day],K+i,1);
		}
	    }
	  add_edge(K+i,t,1);
	}


      cout << max_flow(s,t) << endl;

    }
  return 0;
}