#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef struct tmp {
	struct tmp * next;
	int value;
}element;

typedef struct {
	element * first;
	element * next;
	int count;
}menge;

menge * neu ()
{
	menge * set;
	set = malloc (sizeof (menge));
	set->count = 0;
	set->next = NULL;
	/* Dummy Element am Anfang der Liste */
	set->first = malloc (sizeof (element));
	set->first->next = NULL;
	return set;
}

void zerstoeren (menge * set)
{
	element * elem, * tmp;
	assert (set != NULL);
	elem = set->first;
	free (set);
	while (elem) {
		tmp = elem;
		elem = elem->next;
		free (tmp);
	}
}

void einfuegen (menge * set, int value)
{
	element * elem, * new;
	assert (set != NULL);
	elem = set->first;
	while (elem->next && (elem->next->value < value)) {
		elem = elem->next;
	}
	if (elem->next && (elem->next->value == value))
		return;
	new = malloc (sizeof (element));
	new->value = value;
	new->next = elem->next;
	elem->next = new;
	set->count++;
}

void entfernen (menge * set, int value)
{
	element * elem, * tmp;
	assert (set != NULL);
	elem = set->first;
	while (elem->next && (elem->next->value < value)) {
		elem = elem->next;
	}
	if (elem->next == NULL)
		return;
	if (elem->next->value != value)
		return;
	tmp = elem->next;
	elem->next = elem->next->next;
	if (set->next == tmp)
		set->next = tmp->next;
	free (tmp);
	set->count--;
}

int zaehlen (menge * set)
{
	assert (set != NULL);
	return set->count;
}

int enthalten (menge * set, int value)
{
	element * elem;

	assert (set != NULL);
	elem = set->first->next;
	while (elem && (elem->value < value)) {
		elem = elem->next;
	}
	if (!elem)
		return 0;
	return (elem->value == value);
}

void first (menge * set)
{
	assert (set != NULL);
	set->next = set->first->next;
}

int next (menge * set, int * ptr)
{
	if (set->next) {
		*ptr = set->next->value;
		set->next = set->next->next;
		return 1;
	}
	return 0;
}

typedef struct author {
	char name[50];
	int number;
	menge * coauthors;
}author;


int main () {
	author * authors;	
	menge * current, * tmp;
	int paperauthors[30];
	int count, val, new, i, j, k;
	int N, P;
	int nextnumber;


	scanf ("%d", &N);
	assert (N > 0);
	authors = malloc (N*sizeof (author));
	for (i=0; i<N; ++i) {
		scanf ("%s", authors[i].name);
		authors[i].number = -1;
		authors[i].coauthors = neu();
	}
	scanf ("%d", &P);
	assert (P >= 0);
	for (i=0; i<P; ++i) {
		scanf ("%*s");
		count = 0;
		while (scanf ("%d", &(paperauthors[count])) == 1) {
			count++;
		}
		for (j=0; j<count; ++j) {
			for (k=0; k<j; ++k) {
				assert (paperauthors[j] != paperauthors[k]);
				einfuegen (authors[paperauthors[j]].coauthors, 
				           paperauthors[k]);
				einfuegen (authors[paperauthors[k]].coauthors, 
				           paperauthors[j]);
			}
		}
	}
	nextnumber = 1;
	current = neu ();
	tmp = neu ();
	einfuegen (current, 0);
	authors[0].number = 0;
	while (zaehlen (current) > 0) {
		first (current);
		while (next (current, &val)) {
			first (authors[val].coauthors);
			while (next (authors[val].coauthors, &new)) {
				if (authors[new].number >= 0)
					continue;
				authors[new].number = nextnumber;
				einfuegen (tmp, new);
			}
		}
		nextnumber++;
		zerstoeren (current);
		current = tmp;
		tmp = neu ();
	}

	for (i=0; i<N; ++i) {
		printf ("%s: ", authors[i].name);
		if (authors[i].number < 0) {
			printf (" unendlich\n");
		} else {
			printf ("%d\n", authors[i].number);
		}
	}
	return 0;
}