#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
using UI = unsigned int;
using UC = unsigned char;
using VI = std::vector<int>;
using SI = std::set<int>;
using PI = std::pair<int, int>;
using PL = std::pair<LL, LL>;
constexpr LL MOD = 1000000009;
constexpr double EXP = 2.7182818284590452;
constexpr double Pi = 3.1415926535;
constexpr long double EPS = 1e-4;
constexpr int INF = 1000 * 1000 * 1001;
constexpr long long INFL = (LL)INF * (LL)INF;
inline LL gcd(LL a, LL b) {
  if (a < b) swap(a, b);
  while (b != 0) {
    a %= b;
    swap(a, b);
  }
  return a;
}
inline LL lcm(LL a, LL b) { return (a / gcd(a, b)) * b; }
LL extgcd(LL a, LL b, LL& x, LL& y) {
  if (a == 0) {
    x = 0;
    y = 1;
    return b;
  }
  LL x11, y11;
  LL d = extgcd(b % a, a, x11, y11);
  x = y11 - (b / a) * x11;
  y = x11;
  return d;
}
ULL poww(ULL v, ULL p, ULL mod) {
  if (p == 0) return 1;
  if (p & 1) {
    return (poww(v, p - 1, mod) * v) % mod;
  } else {
    ULL t = poww(v, p / 2, mod);
    return (t * t) % mod;
  }
}
constexpr ULL L31018 = 3000000000000000000L;
constexpr ULL L1018 = 1000000000000000000L;
int const MAXN = 1003;
int n;
vector<int> G[MAXN * MAXN];
vector<string> indexToName;
map<string, int> nameToIndex;
vector<int> indexToVersion;
map<int, int> versionToIndex;
vector<pair<int, int>> takenProjects;
int GetNameIndex(char const* const name) {
  auto const iter = nameToIndex.find(name);
  if (iter != nameToIndex.end()) {
    return iter->second;
  }
  int const index = indexToName.size();
  nameToIndex[name] = index;
  indexToName.emplace_back(name);
  return index;
}
int GetVersionIndex(int const version) {
  auto const iter = versionToIndex.find(version);
  if (iter != versionToIndex.end()) {
    return iter->second;
  }
  int const index = indexToVersion.size();
  versionToIndex[version] = index;
  indexToVersion.emplace_back(version);
  return index;
}
int GetProjectIndex(int const nameIndex, int const versionIndex) {
  return nameIndex + versionIndex * MAXN;
}
int GetVersionFromProjectIndex(int const projectIndex) {
  int const versionIndex = projectIndex / MAXN;
  return indexToVersion[versionIndex];
}
int GetNameIndexFromProjectIndex(int const projectIndex) {
  return projectIndex % MAXN;
}
void PrintResult() {
  map<string, int> result;
  int index = 0;
  for (auto const project : takenProjects) {
    if (project.first >= 0) {
      result[indexToName[index]] = project.first;
    }
    ++index;
  }
  printf("%d\n", result.size());
  for (auto const project : result) {
    printf("%s %d\n", project.first.c_str(), project.second);
  }
}
void Read() {
  static char buff[15];
  int m, v;
  int a, b;
  cin >> n;
  indexToName.reserve(n);
  indexToVersion.reserve(n);
  takenProjects.assign(n, make_pair(-1, MAXN + 1));
  for (int i = (0); i < (n); ++i) {
    scanf("%s%d", buff, &v);
    a = GetProjectIndex(GetNameIndex(buff), GetVersionIndex(v));
    scanf("%d", &m);
    for (int j = (0); j < (m); ++j) {
      scanf("%s%d", buff, &v);
      b = GetProjectIndex(GetNameIndex(buff), GetVersionIndex(v));
      G[a].push_back(b);
    }
  }
  takenProjects[0].second = 0;
}
bool was[MAXN * MAXN];
set<int> layer[MAXN];
void Solve() {
  int currentLayerIndex = 0;
  int nextLayerIndex = 1;
  int version;
  int nameIndex;
  int currentDistance = 0;
  layer[currentLayerIndex].insert(0);
  while (!layer[currentLayerIndex].empty()) {
    ++currentDistance;
    nextLayerIndex = currentLayerIndex + 1;
    auto& nextLayer = layer[nextLayerIndex];
    nextLayer.clear();
    for (auto const projectIndex : layer[currentLayerIndex]) {
      if (was[projectIndex]) {
        continue;
      }
      was[projectIndex] = true;
      nextLayer.insert(G[projectIndex].begin(), G[projectIndex].end());
    }
    for (auto const projectIndex : nextLayer) {
      version = GetVersionFromProjectIndex(projectIndex);
      nameIndex = GetNameIndexFromProjectIndex(projectIndex);
      if (currentDistance <= takenProjects[nameIndex].second) {
        if (takenProjects[nameIndex].first < version) {
          takenProjects[nameIndex] = make_pair(version, currentDistance);
        }
      }
    }
    nextLayer.clear();
    int nameIndex = 0;
    for (auto const project : takenProjects) {
      if (project.second == currentDistance) {
        nextLayer.insert(
            GetProjectIndex(nameIndex, GetVersionIndex(project.first)));
      }
      ++nameIndex;
    }
    currentLayerIndex = nextLayerIndex;
  }
}
void accept() {
  Read();
  Solve();
  PrintResult();
}
int main(void) {
  accept();
  return 0;
}
