#include <bits/stdc++.h>
using namespace std;
enum colorDfs { BLANCO, GRIS, NEGRO };
struct regla {
  int id, diamantes, deMonstruo;
  vector<int> monstruos;
};
const long long MAXN = 100007, OO = (long long)(1e18);
colorDfs color[MAXN];
long long d[MAXN];
vector<regla> reglas[MAXN];
bool visto[MAXN];
vector<pair<pair<int, int>, int> > perteneceA[MAXN];
int sumaMin[MAXN], diamMax[MAXN], k[MAXN];
int ocurr[MAXN];
bool esUnaReglaMala(regla& r) {
  for (auto m : r.monstruos) {
    if (d[m] == OO) {
      return true;
    }
  }
  return false;
}
void dfsVisit(int u) {
  color[u] = GRIS;
  for (auto r : reglas[u]) {
    if (esUnaReglaMala(r)) {
      continue;
    }
    int sumaMax = r.diamantes;
    for (auto v : r.monstruos) {
      switch (color[v]) {
        case BLANCO:
          dfsVisit(v);
          if (diamMax[v] > 0) {
            sumaMax += diamMax[v];
          }
          break;
        case GRIS:
          diamMax[v] = -2;
          break;
        case NEGRO:
          sumaMax += diamMax[v];
          break;
      }
      if (diamMax[v] == -2) {
        diamMax[u] = -2;
        color[u] = NEGRO;
        return;
      }
    }
    diamMax[u] = max(diamMax[u], sumaMax);
  }
  color[u] = NEGRO;
}
void dfs(int n) {
  for (int u = 0; u < n; u++) {
    if (color[u] == BLANCO) {
      dfsVisit(u);
    }
  }
}
void dijkstra(int n) {
  priority_queue<pair<long long, int> > Q;
  for (int u = 0; u < n; u++) {
    d[u] = OO;
    for (auto r : reglas[u]) {
      if (r.monstruos.size() == 0) {
        if (r.diamantes < d[u]) {
          d[u] = r.diamantes;
          Q.push({-d[u], u});
        }
      }
      k[r.id] = r.monstruos.size();
    }
  }
  while (!Q.empty()) {
    int u = Q.top().second;
    Q.pop();
    if (visto[u]) {
      continue;
    }
    visto[u] = true;
    for (auto p : perteneceA[u]) {
      regla r = reglas[p.first.first][p.first.second];
      int ocurrencias = p.second;
      k[r.id] -= ocurrencias;
      sumaMin[r.id] += d[u] * ocurrencias;
      if (k[r.id] == 0 and d[r.deMonstruo] > sumaMin[r.id] + r.diamantes) {
        d[r.deMonstruo] = sumaMin[r.id] + r.diamantes;
        Q.push({-d[r.deMonstruo], r.deMonstruo});
      }
    }
  }
}
void resolver(int n) {
  dijkstra(n);
  dfs(n);
  const long long UPPER = 314000000;
  for (int u = 0; u < n; u++) {
    if (d[u] < OO) {
      cout << min(d[u], UPPER) << " " << min((long long)diamMax[u], UPPER);
    } else {
      cout << "-1 -1";
    }
    cout << "\n";
  }
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  int m, n;
  cin >> m >> n;
  for (int i = 0; i < m; i++) {
    int mi, li;
    cin >> mi >> li;
    mi--;
    regla r;
    r.id = i;
    r.deMonstruo = mi;
    r.diamantes = 0;
    for (int j = 0; j < li; j++) {
      int x;
      cin >> x;
      x--;
      if (x >= 0) {
        ocurr[x]++;
        r.monstruos.push_back(x);
      } else {
        r.diamantes++;
      }
    }
    for (auto m : r.monstruos) {
      if (ocurr[m])
        perteneceA[m].push_back({{mi, reglas[mi].size()}, ocurr[m]});
      ocurr[m] = 0;
    }
    reglas[mi].push_back(r);
  }
  resolver(n);
  return 0;
}
