```go
package main

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

type Project struct {
	name    string
	version int
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	scanString := func() string {
		scanner.Scan()
		return scanner.Text()
	}

	scanInt := func() int {
		scanner.Scan()
		v, _ := strconv.Atoi(scanner.Text())
		return v
	}

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())

	g := make(map[string]map[int][]Project)

	var polycarpName string
	var polycarpVersion int

	for i := 0; i < n; i++ {
		name := scanString()
		version := scanInt()
		if i == 0 {
			polycarpName = name
			polycarpVersion = version
		}
		k := scanInt()
		deps := make([]Project, k)
		for j := 0; j < k; j++ {
			deps[j] = Project{name: scanString(), version: scanInt()}
		}
		if g[name] == nil {
			g[name] = make(map[int][]Project)
		}
		g[name][version] = deps
	}

	resolved := make(map[string]int)
	resolved[polycarpName] = polycarpVersion

	active := []Project{{polycarpName, polycarpVersion}}

	for len(active) > 0 {
		nextLevel := make(map[string]int)
		for _, p := range active {
			deps := g[p.name][p.version]
			for _, dep := range deps {
				if _, ok := resolved[dep.name]; !ok {
					if nextLevel[dep.name] < dep.version {
						nextLevel[dep.name] = dep.version
					}
				}
			}
		}

		active = nil
		for name, version := range nextLevel {
			resolved[name] = version
			active = append(active, Project{name, version})
		}
	}

	var names []string
	for name := range resolved {
		if name != polycarpName {
			names = append(names, name)
		}
	}
	sort.Strings(names)

	fmt.Printf("%d\n", len(names))
	for _, name := range names {
		fmt.Printf("%s %d\n", name, resolved[name])
	}
}
```