import java.util.*;
import java.util.regex.*;
import static java.lang.Math.*;
import static java.util.Collections.*;

class Party
{
	Set<String> nominee = new LinkedHashSet<String>(); // 候補者名簿 (input)
	int         vote;                                  // 得票数     (input)

	int    s_seated; // 小選挙区での当選者数 (calculated)
	int    hv;       // 議席配分(小数)       (calculated) : ただし整数演算にしたいので、得票数合計を掛けた値
	int    seats;    // 議席配分(実際の値)   (calculated)
}

class Nominee
{
	String name;  // 名前     (input)
	Party  party; // 所属政党 (input)
	int    vote;  // 得票数   (input)
}

class EOI extends Exception {}

class Election
{
	public static void main( String[] args )
	{
		try {
			int nCases=0;
			for(Scanner in = new Scanner(System.in) ;; ) {
				new Election(in).solve();

				// The number of data sets in the input does not exceed fifty.
				++nCases;
				assert nCases<=50;
			}

		} catch ( EOI e ) {}
	}

	final int                 SEAT;                                   // 議席定数
	final Map<String,Party>   PARTY = new HashMap<String,Party>();    // 政党リスト
	final List<List<Nominee>> SHOS  = new ArrayList<List<Nominee>>(); // 小選挙区リスト

	// read the input -------------------------------------------------------

	Election( Scanner in ) throws EOI
	{
		Map<String, String> personToParty = new HashMap<String,String>();
		Set<String> personAppearedInSingle = new HashSet<String>();
		Set<String> partyNames = new HashSet<String>();
		Set<String> candiNames = new HashSet<String>();

		      SEAT = in.nextInt();
		int nPARTY = in.nextInt();
		if( SEAT==0 && nPARTY==0 )
			throw new EOI();

		// The number of parties, the number of seats ... do not exceed 20, 200 ...
		assert 0<nPARTY && nPARTY<=20;
		assert 0<SEAT && SEAT<=200;

		long pvote_sum = 0;                             // for assertion
		Set<Integer> pvoteset = new HashSet<Integer>(); // for assertion
		for(int i=0; i<nPARTY; ++i)
		{
			Party p = new Party();

			String pname = in.next();
			int    pnom  = in.nextInt();
			p.vote       = in.nextInt();
			for(int j=0; j<pnom; ++j) {
				String pers = in.next();
				p.nominee.add(pers);

				// The name of each candidate is a string up to twenty characters that begins with a
				// lowercase character and consists of only lowercase and numeric characters.
				assert Pattern.matches("[a-z][a-z0-9]{0,19}", pers );

				// Every candidate belongs to just one of the parties. 
				assert !personToParty.containsKey(pers);
				personToParty.put(pers, pname); // for assertion
				candiNames.add(pers); // for assertion
			}
			assert 0<=p.vote && p.vote<=10000000;

			PARTY.put(pname, p);

			pvote_sum += p.vote; // for assertion
			// The name of each party is a string up to ten characters that begins with an
			// uppercase character and consists of only uppercase and numeric characters.
			assert Pattern.matches("[A-Z][A-Z0-9]{0,9}", pname );

			// No multiple parties or candidates have the same name.
			assert !partyNames.contains(pname);
			partyNames.add(pname);

			// No two or more parties receive the same number of party votes.
			assert !pvoteset.contains(p.vote);
			pvoteset.add(p.vote); // for assertion
		}

		// Neither the total number of party votes nor the total
		// number of votes in each constituency exceeds 10,000,000.
		assert 0<pvote_sum && pvote_sum<=10000000;

		for(int i=0; i<SEAT/2; ++i)
		{
			long nvote_sum = 0; // for assertion
			Set<Integer> nvoteset = new HashSet<Integer>(); // for assertion

			List<Nominee> sd = new ArrayList<Nominee>();

			int anom = in.nextInt();
			for(int j=0; j<anom; ++j)
			{
				Nominee n = new Nominee();
				n.name  = in.next();
				String partyName = in.next();
				n.party = PARTY.get( partyName );
				n.vote  = in.nextInt();
				sd.add(n);

				nvote_sum += n.vote; // for assertion
				// The name of each candidate is a string up to twenty characters that begins with a
				// lowercase character and consists of only lowercase and numeric characters.
				assert Pattern.matches("[a-z][a-z0-9]{0,19}", n.name );

				// Also, in each constituency, no two or more candidates receive the same
				// number of constituency votes.
				assert !nvoteset.contains(n.vote) : n.name;
				nvoteset.add(n.vote); // for assertion
				assert 0<=n.vote && n.vote<=10000000;

				// Every candidate belongs to just one of the parties. 
				// No multiple parties or candidates have the same name.
				assert !personToParty.containsKey(n.name) || personToParty.get(n.name).equals(partyName);
				personToParty.put(n.name, partyName); // for assertion

				// No candidate is allowed to compete in more than one constituency.
				assert !personAppearedInSingle.contains(n.name) : n.name+" competes in more than one district";
				personAppearedInSingle.add(n.name); // for assertion
			}
			SHOS.add(sd);

			// Neither the total number of party votes nor the total
			// number of votes in each constituency exceeds 10,000,000.
			assert 0<nvote_sum && nvote_sum<=10000000;

			// The total number of different candidates do not ... 1,000
			assert 0<candiNames.size() && candiNames.size()<=1000;
		}
	}

	// solve ----------------------------------------------------------------

	static boolean fst = true;

	void solve()
	{
		// 空行 between テストケース
		if( fst ) fst = false; else System.out.println();

		// 選挙する
		List<String> e = doElection();

		// 辞書順に表示
		sort(e);
		for( String s : e )
			System.out.println(s);
	}

	List<String> doElection()
	{
		List<String> e = new ArrayList<String>();
		doShosenkyoku(e); // 小選挙区の当選者を計算
		doHireiku(e);     // 比例区の当選者を計算
		return e;
	}

	void doShosenkyoku( List<String> e )
	{
		for( List<Nominee> sd : SHOS )
		{
			// 得票数最大の人を
			Nominee w = max(sd, new Comparator<Nominee>(){
				public int compare(Nominee lhs, Nominee rhs) {
					return lhs.vote<rhs.vote ? -1 : lhs.vote>rhs.vote ? +1 : 0;
				}});

			// 当選者リストに追加
			e.add( w.name );

			// 所属政党の小選挙区獲得議席を１増やす
			w.party.s_seated ++;

			// 所属政党の比例区の名簿から外す
			w.party.nominee.remove(w.name);
		}
	}

	void doHireiku( List<String> e )
	{
		// 比例区で議席をもらえる政党のリストを作成
		//   政党.select {比例区得票数>=5% || 小選挙区当選者数>=3}
		List<Party> hParties = new ArrayList<Party>();
		final int hsum_vote;
		{
			int sum_vote = 0;
			for( Party p : PARTY.values() ) sum_vote += p.vote;

			int hh = 0;
			for( Party p : PARTY.values() )
				if( p.vote >= sum_vote/20 || p.s_seated >= 3 )
				{
					hParties.add(p);
					hh += p.vote;
				}
			hsum_vote = hh;
		}

		// 議席配分
		{
			int amari = SEAT;
			for( Party p : hParties )
			{
				// 比例区得票数×議席定数÷全"対象"政党の得票数の合計
				p.hv    = p.vote * SEAT; // * 1.0 / hsum_vote;
				// の整数部分
				p.seats = p.hv / hsum_vote;
				// 余り
				amari  -= p.seats;
			}

			// (小数部(hv),得票数) の多い順にソート
			sort( hParties, new Comparator<Party>(){
				public int compare( Party lhs, Party rhs ) {
					if( lhs.hv%hsum_vote < rhs.hv%hsum_vote ) return +1;
					if( lhs.hv%hsum_vote > rhs.hv%hsum_vote ) return -1;
					return lhs.vote<rhs.vote ? +1 : lhs.vote>rhs.vote ? -1 : 0;
				}});

			// 余りは上から順に１議席ずつわりあて
			for( Party p : hParties.subList(0, amari) )
				p.seats ++;
		}

		// 比例区の当選者決定 (名簿の上から順にとってくるだけ)
		for( Party p : hParties ) {
			e.addAll( list(enumeration(p.nominee)).subList(0, max(0, p.seats-p.s_seated)) );

			// Each party list contains enough candidates, that is, the party can always
			// choose the required number of candidates from the list.
			assert p.seats-p.s_seated <= p.nominee.size();
		}
	}
}