Go: package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	io := NewIo()
	defer io.Flush()

	for {
		N := io.NextInt()
		if N == 0 {
			break
		}
		set := make([]map[int]struct{}, N)
		for i := 0; i < N; i++ {
			set[i] = make(map[int]struct{})
			M := io.NextInt()
			for j := 0; j < M; j++ {
				p := io.NextInt()
				set[i][p] = struct{}{}
			}
		}
		K := io.NextInt()
		l := make([]int, K)
		for i := 0; i < K; i++ {
			l[i] = io.NextInt()
		}

		ans := 0
	FOR_OUTER:
		for i := 0; i < N; i++ {
			for j := 0; j < K; j++ {
				if _, f := set[i][l[j]]; f == false {
					continue FOR_OUTER
				}
			}
			switch ans {
			case 0:
				ans = i + 1
			default:
				ans = -1
			}
		}
		if ans > 0 {
			io.Println(ans)
		} else {
			io.Println(-1)
		}
	}
}

// I/O template
type Io struct {
	reader    *bufio.Reader
	writer    *bufio.Writer
	tokens    []string
	nextToken int
}

func NewIo() *Io {
	return &Io{
		reader: bufio.NewReader(os.Stdin),
		writer: bufio.NewWriter(os.Stdout),
	}
}

func (io *Io) Flush() {
	err := io.writer.Flush()
	if err != nil {
		panic(err)
	}
}

func (io *Io) NextLine() string {
	var buff []byte
	for {
		line, isPrefix, err := io.reader.ReadLine()
		if err != nil {
			panic(err)
		}
		buff = append(buff, line...)
		if !isPrefix {
			break
		}
	}
	return string(buff)
}

func (io *Io) Next() string {
	for io.nextToken >= len(io.tokens) {
		line := io.NextLine()
		io.tokens = strings.Fields(line)
		io.nextToken = 0
	}
	s := io.tokens[io.nextToken]
	io.nextToken++
	return s
}

func (io *Io) NextInt() int {
	i, err := strconv.Atoi(io.Next())
	if err != nil {
		panic(err)
	}
	return i
}

func (io *Io) NextFloat() float64 {
	i, err := strconv.ParseFloat(io.Next(), 64)
	if err != nil {
		panic(err)
	}
	return i
}

func (io *Io) Println(a ...interface{}) {
	fmt.Fprintln(io.writer, a...)
}

func (io *Io) Printf(format string, a ...interface{}) {
	fmt.Fprintf(io.writer, format, a...)
}

func (io *Io) PrintIntSlice(a []int) {
	b := []interface{}{}
	for _, x := range a {
		b = append(b, x)
	}
	io.Println(b...)
}

func (io *Io) PrintStringSlice(a []string) {
	b := []interface{}{}
	for _, x := range a {
		b = append(b, x)
	}
	io.Println(b...)
}

func Log(name string, value interface{}) {
	fmt.Fprintf(os.Stderr, "%s=%+v\n", name, value)
}

func ExampleIo() {
	io := NewIo()
	defer io.Flush()
	a := make([]int, 0, 3)
	a[0], a[1], a[2] = io.NextInt(), io.NextInt(), io.NextInt()
	io.Println(a)
	io.PrintIntSlice(a)
	Log("io", a)
}

C++: #include <iostream>
#include <algorithm>
#include <functional>
#include <cstdlib>
#include <sstream>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <complex>
#include <vector>
#include <bitset>
#include <cstdio>
#include <cmath>
#include <time.h>
#include <tuple>
#define all(c) ((c).begin(),(c).end())
#define rall(c) ((c).rbegin(),(c).rend())
//#define sort(v,n) sort(v,v+n)
#define ll long long
#define fi first
#define se second
#define inf 999999999
using namespace std;
const ll MOD = 1e9 + 7;
const double PI = acos(-1.0);
//---------------------------------------------------------------------------------------------//


int n;

int main() {
	while (cin >> n, n) {
		vector< vector <int> > vv(110);
		bool b[110];
		for (int i = 0; i < n; i++) {
			b[i] = 1;
			int m; cin >> m;
			for (int j = 0; j < m; j++) {
				int a; cin >> a;
				vv[i].push_back(a);
			}
		}
		int k; cin >> k;
		for (int i = 0; i < k; i++) {
			int a; cin >> a;
			for (int j = 0; j < n; j++) {
				auto ite = find(vv[j].begin(), vv[j].end(),a);
				if (ite != vv[j].end()) {
					vv[j].erase(ite);
				}
				else {
					b[j] = 0;
				}
			}
		}
		int mujunn = 0;
		int ans;
		for (int i = 0; i < n; i++) {
			if (b[i]) {
				ans = i + 1;
				mujunn++;
			}
		}
		if (mujunn < 1 || mujunn>1) {
			cout << -1 << endl;
		}
		else {
			cout << ans << endl;
		}
	}
	return 0;
}

C++: #include <iostream>

using namespace std;

int main()
{
  int n;
  int i,j,k;
  while(1){
	cin >> n;
	if(n == 0) break;
	int m[100];
	int p[100][100];

	for (i = 0; i < n; i++) {
	  cin >> m[i];
	  for (j = 0; j < m[i]; j++) {
		cin >> p[i][j];
	  }
	}
	cin >> k;
	int hoge;
	int l[100];
	for(hoge = 0;hoge < k; hoge ++){
	  cin >> l[hoge];
	}

	int ans = 0;
	int c = 0;

	for(i = 0; i < n; i++){
	  for(j = 0; j < m[i]; j++){
		for(int a = 0; a < k; a++){
		  if(l[a] == p[i][j]){
			c++;
			break;
		  }else if(l[a] > p[i][j]){
			break;
		  }
		}
		if(c == k){
		  if(ans == 0) {
			ans = (i+1);
			// cout << i << endl;
			c = 0;
			break;
		  }
		  else {
			ans = -1;
			break;
		  }
		}
	  }
	  c = 0;
	}

	if(ans == 0) ans = -1;


	cout << ans << endl;

  }
  return 0;
}

C++: #include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <set>
#include <map>
#include <string>
#include <stack>
#include <queue>
#include <cmath>
#include <cstdio>
#include <istream>
#include <sstream>
#include <iomanip>
using namespace std;

typedef ostringstream oss;
typedef istringstream iss;

struct Member{
	Member() : isCrim(true) {}
	bool isCrim;
	vector<int> inf;
};

int main(void) {
	int N;
	while (cin >> N, N) {
		vector<Member> mem(N);
		for (int i = 0; i < N; i++) {
			int M;
			cin >> M;
			for (int j = 0; j < M; j++) {
				int t;
				cin >> t;
				mem[i].inf.push_back(t);
			}
		}
		vector<int> outInf;
		int K;
		cin >> K;
		for (int i = 0; i < K; i++) {
			int t;
			cin >> t;
			outInf.push_back(t);;
		}

		for (int ci = 0; ci < K; ci++) {
			for (int mi = 0; mi < N; mi++) {
				if (!mem[mi].isCrim) {
					continue;
				}
				if (find(mem[mi].inf.begin(), mem[mi].inf.end(), outInf[ci]) == mem[mi].inf.end()) {
					mem[mi].isCrim = false;
				}
			}
		}

		int crimNum = 0, crimIndex;
		for (int mi = 0; mi < N; mi++) {
			if (mem[mi].isCrim) {
				crimNum++;
				crimIndex = mi;
			}
		}

		//cout << "--- ";
		if (crimNum == 1) {
			cout << crimIndex + 1 << endl;
		}else {
			cout << -1 << endl;
		}
	}

	return 0;
}

C++: #include <iostream>
#include <vector>
#include <set>

using std::cin;
using std::cout;
using std::endl;
using std::vector;
using std::set;

bool intension(set<int>& s1, set<int>& s2) {
	if (s1.size() < s2.size()) {
		return false;
	}

	for (set<int>::iterator itr = s2.begin(); itr != s2.end(); ++itr) {
		if ((s1.find(*itr)) == s1.end()) {
			return false;
		}
	}
	return true;
}

int main(void) {
	int N;
	cin >> N;

	while (N != 0) {
		vector< set<int> > data(N+1);
		int cri = -1;
		int count = 0;
		int temp;
		int M;
		for (int i = 0; i < N+1; i++) {
			cin >> M;
			for (int j = 0; j < M; j++) { 
				cin >> temp;
				data[i].insert(temp);
			}
			
		}

		for (int i = 0; i < N; i++) {
			if (count < 2) {
				if (intension(data[i], data[N])) {
					cri = i+1;
					count++;
				}
			}
		}
		if (count > 1) {
			cout << -1 << endl;
		}
		else {
			cout << cri << endl;
		}

		cin >> N;
	}

	return 0;
}

C++: //hogehgoe

//#include<gchost.h>
#include<iostream>
#include<vector>
#include<stack>
#include<map>
#include<string>
#include<queue>
#include<algorithm>
#include<set>
#include<cmath>
using namespace std;

int main()
{
	int N;
	while(cin>>N && N!=0){
		vector<vector<int> > V(N);
		for(int i=0;i<N;i++){
			int M;
			cin>>M;
			for(int j=0;j<M;j++){
				int t; cin>>t;
				V[i].push_back(t);
			}
		}

		vector<int> target;
		int K; cin>>K;
		for(int i=0;i<K;i++){
			int t;cin>>t;
			target.push_back(t);
		}

		int ans=-1,num=0;

		for(int i=0;i<N;i++){
			bool ok=false;
			for(int k=0;k<K;k++){
				ok=false;
				for(int idx=0;idx<V[i].size();idx++){
					if(V[i][idx]==target[k]){ok=true;break;}
				}
				if(!ok) break;
			}
			if(ok){ans=i;num++;}
		}
		if(num!=1) cout<<-1<<endl;
		else cout<<ans+1<<endl;
	}
	return 0;
}