Problem: Polycarp is currently developing a project in Vaja language and using a popular dependency management system called Vamen. From Vamen's point of view both Vaja project and libraries are treated projects for simplicity.

A project in Vaja has its own uniqie non-empty name consisting of lowercase latin letters with length not exceeding 10 and version — positive integer from 1 to 106. Each project (keep in mind that it is determined by both its name and version) might depend on other projects. For sure, there are no cyclic dependencies.

You're given a list of project descriptions. The first of the given projects is the one being developed by Polycarp at this moment. Help Polycarp determine all projects that his project depends on (directly or via a certain chain). 

It's possible that Polycarp's project depends on two different versions of some project. In this case collision resolving is applied, i.e. for each such project the system chooses the version that minimizes the distance from it to Polycarp's project. If there are several options, the newer (with the maximum version) is preferred. This version is considered actual; other versions and their dependencies are ignored.

More formal, choose such a set of projects of minimum possible size that the following conditions hold: 

  * Polycarp's project is chosen; 
  * Polycarp's project depends (directly or indirectly) on all other projects in the set; 
  * no two projects share the name; 
  * for each project x that some other project in the set depends on we have either x or some y with other version and shorter chain to Polycarp's project chosen. In case of ties the newer one is chosen. 



Output all Polycarp's project's dependencies (Polycarp's project itself should't be printed) in lexicographical order.

Input

The first line contains an only integer n (1 ≤ n ≤ 1 000) — the number of projects in Vaja.

The following lines contain the project descriptions. Each project is described by a line consisting of its name and version separated by space. The next line gives the number of direct dependencies (from 0 to n - 1) and the dependencies themselves (one in a line) in arbitrary order. Each dependency is specified by its name and version. The projects are also given in arbitrary order, but the first of them is always Polycarp's. Project descriptions are separated by one empty line. Refer to samples for better understanding.

It's guaranteed that there are no cyclic dependencies. 

Output

Output all Polycarp's project's dependencies in lexicographical order.

Examples

Input

4
a 3
2
b 1
c 1
 
b 2
0
 
b 1
1
b 2
 
c 1
1
b 2


Output

2
b 1
c 1


Input

9
codehorses 5
3
webfrmk 6
mashadb 1
mashadb 2
 
commons 2
0
 
mashadb 3
0
 
webfrmk 6
2
mashadb 3
commons 2
 
extra 4
1
extra 3
 
extra 3
0
 
extra 1
0
 
mashadb 1
1
extra 3
 
mashadb 2
1
extra 1


Output

4
commons 2
extra 1
mashadb 2
webfrmk 6


Input

3
abc 1
2
abc 3
cba 2

abc 3
0

cba 2
0


Output

1
cba 2

Note

The first sample is given in the pic below. Arrow from A to B means that B directly depends on A. Projects that Polycarp's project «a» (version 3) depends on are painted black.

<image>

The second sample is again given in the pic below. Arrow from A to B means that B directly depends on A. Projects that Polycarp's project «codehorses» (version 5) depends on are paint it black. Note that «extra 1» is chosen instead of «extra 3» since «mashadb 1» and all of its dependencies are ignored due to «mashadb 2».

<image>

Solution (in JAVA):

Solution:
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;

public class Main {


    public static boolean check(int n, int[] mas, int v, int cow){
        int k = 1;
        int l = 0;
        for(int i = 1; i < n; i++){
            if(mas[i] - mas[l] >= v){
                k++;
                l = i;
            }
        }
        if (k >= cow) return true;
        else return false;
    }

    public static class Edge {
        String name;
        int version;

        public Edge(String name, int version) {
            this.version = version;
            this.name = name;
        }
    }

    public static class EdgeSt {
        int version;
        int gl;

        public EdgeSt(int version, int gl) {
            this.version = version;
            this.gl = gl;
        }
    }


    public static void main(String[] args) throws IOException {
        FastScanner in = new FastScanner(System.in);
        FastPrinter out = new FastPrinter(System.out);
        //FastScanner in = new FastScanner(new InputStreamReader(new FileInputStream(new File("cows.in"))));
        //FastPrinter out = new FastPrinter(new OutputStreamWriter(new FileOutputStream(new File("cows.out"))));
        int n = in.nextInt();

        HashMap<Edge, ArrayList<Edge>> mp = new HashMap<>();
        HashMap<String, EdgeSt> mapUse = new HashMap<>();
        HashMap<String, Integer> mpIndex = new HashMap<>();

        ArrayList<String> listAns = new ArrayList();
        ArrayList<Edge> mas = new ArrayList<>();



        for(int i = 0; i < n; i++){
            String st = in.next();
            int v = in.nextInt();
            mas.add(new Edge(st, v));

            mpIndex.put(mas.get(i).name + mas.get(i).version, i);

            int k = in.nextInt();
            ArrayList<Edge> ar = new ArrayList<>();
            for(int j = 1; j <= k; j++){
                st = in.next();
                v = in.nextInt();
                ar.add(new Edge(st, v));
            }
            mp.put(mas.get(i), ar);
        }

        ArrayList<Edge> ar;
        ar = mp.get(mas.get(0));
        int k = 0;
        int sise = 0;

        mapUse.put(mas.get(0).name, new EdgeSt(mas.get(0).version, k));

        while (!ar.isEmpty()) {
            k++;
            int siseP = sise;
            //St put EdgrSt gl eq gl
            for (int i = 0; i < ar.size(); i++) {
                Edge current = ar.get(i);
                if(mapUse.get(current.name) != null){
                    int v = mapUse.get(current.name).version;
                    int gl = mapUse.get(current.name).gl;
                    if (gl == k){
                       if(v < current.version){
                           mapUse.put(current.name, new EdgeSt(current.version, k));
                       }
                    }
                }

                else {
                    mapUse.put(current.name, new EdgeSt(current.version, k));
                    listAns.add(current.name);
                    sise++;
                }
            }

            int[] masIndex = new int[sise - siseP];

            for(int i = siseP; i < sise; i++){
                masIndex[i-siseP] = mpIndex.get(listAns.get(i) + mapUse.get(listAns.get(i)).version);
            }



            //go gl > 1

            ArrayList<Edge> newArrayAns = new ArrayList<>();

            for (int i = 0; i < masIndex.length; i++) {
                int p = masIndex[i];
                ArrayList<Edge> arCurrent = mp.get(mas.get(p));

                if(arCurrent != null)
                for (int j = 0; j < arCurrent.size(); j++) {
                    newArrayAns.add(arCurrent.get(j));
                }
            }

            ar = newArrayAns;
        }
        System.out.println(listAns.size());

        String[] sArray = new String[listAns.size()];
        for(int i = 0; i < listAns.size(); i++){
            sArray[i] = listAns.get(i);
        }
        Arrays.sort(sArray);

        for(int i = 0; i < listAns.size(); i++){
            System.out.println(sArray[i] + " " + mapUse.get(sArray[i]).version);
        }

        out.close();
    }
}

class FastPrinter {
    private final PrintWriter writer;

    public FastPrinter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public FastPrinter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void close() {
        writer.close();
    }

    public void println(long i) {
        writer.println(i);
    }

    public void println(double d) {
        writer.println(d);
    }

    public void println(String s) {
        writer.println(s);
    }

    public void println(String format, Object... args) {
        println(String.format(format, args));
    }

    public void println() {
        writer.println();
    }

    public void print(long i) {
        writer.print(i);
    }

    public void print(char c) {
        writer.print(c);
    }

    public void print(double d) {
        writer.print(d);
    }

    public void print(String s) {
        writer.print(s);
    }

    public void print(String format, Object... args) {
        print(String.format(format, args));
    }

    public void flush() {
        writer.flush();
    }
}

class FastScanner {

    private BufferedReader reader;
    private StringTokenizer st;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public FastScanner(InputStream stream) {
        this.reader = new BufferedReader(new InputStreamReader(stream));
        this.st = new StringTokenizer("");
    }

    public FastScanner(InputStreamReader stream) {
        this.reader = new BufferedReader(stream);
        this.st = new StringTokenizer("");
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }

    public String next() {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(readLine());
        }
        return st.nextToken();
    }

    public String nextLine() {
        st = new StringTokenizer("");
        return readLine();
    }

    public String tryNextLine() {
        st = new StringTokenizer("");
        return tryReadLine();
    }

    private String readLine() {
        String line = tryReadLine();
        if (line == null) throw new InputMismatchException();
        return line;
    }

    private String tryReadLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            throw new InputMismatchException();
        }
    }

    public int[] nextIntArray(int size) {
        int[] array = new int[size];
        for (int i = 0; i < size; i++)
            array[i] = nextInt();
        return array;
    }

    public int[][] nextIntTable(int rowCount, int columnCount) {
        int[][] table = new int[rowCount][];
        for (int i = 0; i < rowCount; i++)
            table[i] = nextIntArray(columnCount);
        return table;
    }

    public long[] nextLongArray(int size) {
        long[] array = new long[size];
        for (int i = 0; i < size; i++)
            array[i] = nextLong();
        return array;
    }

    public long[][] nextLongTable(int rowCount, int columnCount) {
        long[][] table = new long[rowCount][];
        for (int i = 0; i < rowCount; i++)
            table[i] = nextLongArray(columnCount);
        return table;
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\t' || isEOL(c);
    }

    public static boolean isEOL(int c) {
        return c == '\n' || c == '\r' || c == -1;
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}

/*
FastScanner in = new FastScanner(new InputStreamReader(new FileInputStream(new File("dijkstra.in"))));
        FastPrinter out = new FastPrinter(new OutputStreamWriter(new FileOutputStream(new File("dijkstra.out"))));
 */