import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;


public class Main {

    LinkedList<Integer>[] adj;
    long[] sigs;
    long[] best;
    boolean[] visited;
    int e;
    int t;
    public void run() {
        try {
            BufferedReader buff = new BufferedReader(new InputStreamReader(System.in));
            while (true) {
                String line = buff.readLine().trim();
                String[] toks = line.split("[ ]+");
                t = Integer.parseInt(toks[0]);
                e = Integer.parseInt(toks[1]);
                if (t == 0 && e == 0) {
                    return;
                }
                adj = new LinkedList[e+t];
                sigs = new long[t+e];
                best = new long[e+t];
                visited = new boolean[e+t];
                for (int i = 0; i < adj.length; i++) {
                    adj[i] = new LinkedList<Integer>();
                }
                for (int i = 0; i < t; i++) {
                    line = buff.readLine().trim();
                    toks = line.split("[ ]+");
                    int bs = Integer.parseInt(toks[0]);
                    int nd = Integer.parseInt(toks[1]);
                    int ne = Integer.parseInt(toks[2]);
                    sigs[i+e] = bs;

                    line = buff.readLine().trim();
                    toks = line.split("[ ]+");

                    for (int j = 0; j < nd; j++) {
                        int tmp = Integer.parseInt(toks[j]);
                        adj[e+i].add(tmp-1+e);
                    }

                    for (int j = nd; j < nd+ne; j++) {
                        int tmp = Integer.parseInt(toks[j]);
                        adj[tmp-1].add(i+e);
                    }
                }
                for (int i = 0; i < best.length; i++) {
                    best[i] = -1;
                    visited[i] = false;
                }
                depmap = new HashMap<Integer, BigInteger>();
                for (int i = 0; i < t; i++) {
                    if (depmap.get(i+e) == null) {
                        dfsDependency(i+e);
                    }
                }

                System.out.println("*****");
                for (int i = 0; i < t; i++) {
                    if (best[i+e] == -1) {
                        best[i+e] = dfs(i+e);
                    }
//                      long ret = dfs(i);
//                      System.out.println((i+1) + " " + ret);
                }

                for (int i = 0; i < e; i++) {
                    long res = 0;
                    Iterator<Integer> tasks = adj[i].iterator();
                    while (tasks.hasNext()) {
                        int task = tasks.next();
                        if (valid(i, task)) {
                            res += best[task];
                        }
                    }
//                  for (int j = 0; j < t; j++) {
//                      if (valid(i, j)) {
//                          res += best[j+e];
//                      }
//                  }
                    System.out.println((i+1) + " " + res);
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public boolean valid(int emp, int task) {
        Iterator<Integer> itr = adj[emp].iterator();
//      task += e;
        while (itr.hasNext()) {
            int curr = itr.next();
            if (curr == task) {
                continue;
            }
            BigInteger num = depmap.get(curr);
            if (!num.and(new BigInteger("1").shiftLeft(task)).equals(BigInteger.ZERO)) {
                return false;
            }
        }
        return true;
    }

    HashMap<Integer, BigInteger> depmap;

    public BigInteger dfsDependency(int node) {
        BigInteger res = new BigInteger("0");
        Iterator<Integer> itr = adj[node].iterator();
        while (itr.hasNext()) {
            int ch = itr.next();
            if (depmap.get(ch) == null) {
                depmap.put(ch, dfsDependency(ch));
            }

            res = res.or(depmap.get(ch));
            res = res.or(new BigInteger("1").shiftLeft(ch));
        }
        depmap.put(node, res);
        return res;
    }

    public long dfs(int n) {
        long res = 0;
        Iterator<Integer> itr = adj[n].iterator();
        while (itr.hasNext()) {
            int ch = itr.next();
            if (best[ch] == -1) {
                best[ch] = dfs(ch);
            }
            res += best[ch];
        }

        best[n] = res+sigs[n];
        return best[n];
    }

    public static void main(String[] args) {
        new Main().run();
    }
}