#include <bits/stdc++.h>
using namespace std;
struct _int128 {
    unsigned long long low;
    long long high;
    bool sign;
    _int128(): low(0), high(0), sign(1) {}
    _int128(unsigned long long a, long long b, bool c = 1):
        low(a), high(b), sign(c) {}
    _int128(char a): low(abs(a)), high(0), sign(a >= 0) {}
    _int128(unsigned char a): low(a), high(0), sign(1) {}
    _int128(short a): low(abs(a)), high(0), sign(a >= 0) {}
    _int128(unsigned short a): low(a), high(0), sign(1) {}
    _int128(int a): low(abs(a)), high(0), sign(a >= 0) {}
    _int128(unsigned int a): low(a), high(0), sign(1) {}
    _int128(long long a): low(abs(a)), high(0), sign(a >= 0) {}
    _int128(unsigned long long a): low(a), high(0), sign(1) {}
    explicit operator char() {
        return (char)low;
    }
    explicit operator unsigned char() {
        unsigned char res = low;

        if (!sign)
            res = -res;

        return res;
    }
    explicit operator short() {
        return (short)low;
    }
    explicit operator unsigned short() {
        unsigned short res = low;

        if (!sign)
            res = -res;

        return res;
    }
    explicit operator int() {
        return (int)low;
    }
    explicit operator unsigned int() {
        unsigned int res = low;

        if (!sign)
            res = -res;

        return res;
    }
    explicit operator long long() {
        return (long long)low;
    }
    explicit operator unsigned long long() {
        unsigned long long res = low;

        if (!sign)
            res = -res;

        return res;
    }

    _int128 operator= (const _int128 &x) {
        low = x.low, high = x.high, sign = x.sign;
        return (*this);
    }
    bool operator!() const {
        return low == 0 && high == 0;
    }
    bool operator== (const _int128 &y) const {
        auto x = (*this);
        return x.sign == y.sign && x.low == y.low && x.high == y.high;
    }
    bool operator< (const _int128 &y) const {
        auto x = (*this);

        if (x.sign < y.sign)
            return 1;

        if (x.sign > y.sign)
            return 0;

        if (x.high < y.high)
            return 1;

        if (x.high > y.high)
            return 0;

        if (x.low < y.low)
            return 1;

        if (x.low > y.low)
            return 0;

        return 0;
    }
    bool operator<= (const _int128 &y) const {
        auto x = (*this);
        return x < y || x == y;
    }
    bool operator> (const _int128 &y) const {
        auto x = (*this);
        return !(x <= y);
    }
    bool operator>= (const _int128 &y) const {
        auto x = (*this);
        return !(x < y);
    }
    _int128 operator- () {
        auto t = (*this);
        t.sign ^= 1;
        return t;
    }
    _int128 add(_int128 x, _int128 y) {
        auto lo = x.low + y.low;
        auto hi = x.high + y.high;
        hi += lo < x.low;
        return _int128(lo, hi);
    }
    _int128 sub(_int128 x, _int128 y) {
        bool neg = false;

        if (x < y)
            swap(x, y), neg = true;

        auto lo = x.low - y.low;
        auto hi = x.high - y.high;
        hi -= x.low < y.low;
        return _int128(lo, hi, !neg);
    }
    _int128 operator+ (_int128 y) {
        auto x = (*this);

        if (x.sign ^ y.sign) {
            if (x < y)
                swap(x, y);

            return sub(x, y);
        } else {
            auto t = add(x, y);
            t.sign ^= !x.sign;
            return t;
        }
    }
    _int128 operator+= (const _int128 &x) {
        return (*this) = (*this) + x;
    }
    _int128 operator- (_int128 y) const {
        auto x = (*this);
        return x + (-y);
    }
    _int128 operator-= (const _int128 &x) {
        return (*this) = (*this) - x;
    }
    _int128 operator<< (const unsigned long long &y) const {
        auto x = (*this);

        if (y > 128)
            return _int128(0, 0);

        if (y >= 64) {
            return _int128(0, x.low << (y - 64), x.sign);
        } else {
            _int128 res = x;
            unsigned long long t = x.low >> (64 - y);
            res.high = (res.high << y) + t;
            res.low = res.low << y;
            return res;
        }
    }
    _int128 operator<<= (const unsigned long long &y) {
        return (*this) = (*this) << y;
    }
    _int128 operator>> (const unsigned long long &y) const {
        auto x = (*this);

        if (y > 128)
            return _int128(0, 0);

        if (y >= 64) {
            return _int128(x.high >> (y - 64), 0, x.sign);
        } else {
            _int128 res = x;
            unsigned long long t = x.high & ((1ll << y) - 1);
            res.low = (res.low >> y) + (t << (64 - y));
            res.high = res.high >> y;
            return res;
        }
    }
    _int128 operator>>= (const unsigned long long &y) {
        return (*this) = (*this) >> y;
    }
    _int128 operator& (_int128 y) {
        auto x = (*this);

        if (!x.sign)
            x.low = ~x.low, x.high = ~x.high;

        if (!y.sign)
            y.low = ~y.low, y.high = ~y.high;

        return _int128(x.low & y.low, abs(x.high & y.high), x.sign | y.sign);
    }
    _int128 operator| (_int128 y) {
        auto x = (*this);

        if (!x.sign)
            x.low = ~x.low, x.high = ~x.high;

        if (!y.sign)
            y.low = ~y.low, y.high = ~y.high;

        return _int128(x.low | y.low, abs(x.high | y.high), x.sign & y.sign);
    }
    _int128 operator^ (_int128 y) {
        auto x = (*this);

        if (!x.sign)
            x.low = ~x.low, x.high = ~x.high;

        if (!y.sign)
            y.low = ~y.low, y.high = ~y.high;

        return _int128(x.low ^ y.low, abs(x.high ^ y.high), !(x.sign ^ y.sign));
    }
    _int128 operator&= (const _int128 &x) {
        return (*this) = (*this) & x;
    }
    _int128 operator|= (const _int128 &x) {
        return (*this) = (*this) | x;
    }
    _int128 operator^= (const _int128 &x) {
        return (*this) = (*this) ^ x;
    }
    _int128 operator* (const _int128 &y) const {
        auto x = (*this);
        long long H = x.high * y.low + x.low * y.high, L = 0;
        unsigned int LH1 = x.low / (1ll << 32), LH2 = y.low / (1ll << 32);
        unsigned int LL1 = x.low, LL2 = y.low;
        H += (long long)LH1 * LH2, L += (unsigned long long)LL1 * LL2;
        _int128 res = _int128(L, H, !(x.sign xor y.sign));
        res += _int128((unsigned long long)LL1 * LH2) << 32;
        res += _int128((unsigned long long)LH1 * LL2) << 32;
        return res;
    }
    _int128 operator*= (const _int128 &y) {
        return (*this) = (*this) * y;
    }
    _int128 operator/ (_int128 y) const {
        auto x = (*this), z = _int128(1);

        while (y <= x)
            y <<= 1, z <<= 1;

        _int128 res = 0;

        while (y > 0) {
            if (x >= y) {
                x -= y;
                res |= z;
            }

            y >>= 1, z >>= 1;
        }

        res.sign = !(x.sign ^ y.sign);
        return res;
    }
    _int128 operator/= (const _int128 &y) {
        return (*this) = (*this) / y;
    }
    _int128 operator% (const _int128 &y) const {
        auto x = (*this);
        return x - x / y * y;
    }
};
typedef _int128 i128;
const int maxn=1e5+5;
i128 gcd(i128 a,i128 b)
{
    return !b?a:gcd(b,a%b);
}
i128 lcm(i128 a,i128 b)
{
    return a/gcd(a,b)*b;
}
struct Frac
{
    i128 fm,fz;
    Frac operator +(const Frac& b)const
    {
        Frac res;
        i128 fm1=fm,fz1=fz,fm2=b.fm,fz2=b.fz;
        if(!fm1)
        {
            res.fm=fm2;
            res.fz=fz2;
            return res;
        }
        if(!fm2)
        {
            res.fm=fm1;
            res.fz=fz1;
            return res;
        }
        i128 _lcm=lcm(fm1,fm2);
        fz1*=(_lcm/fm1);
        fz2*=(_lcm/fm2);
        res.fz=fz1+fz2;
        res.fm=_lcm;
        i128 _gcd=gcd(res.fz,res.fm);
        res.fz/=_gcd;
        res.fm/=_gcd;
        return res;
    }
    Frac operator /(const i128& x)const
    {
        Frac res;
        res.fm=fm*x;
        res.fz=fz;
        if(!fm)return res;
        i128 _gcd=gcd(res.fz,res.fm);
        res.fz/=_gcd;
        res.fm/=_gcd;
        return res;
    }
}val[maxn];
int n,m;
int indu[maxn];
int chudu[maxn];
int head[maxn];
struct EDGE
{
    int to,nxt;
}edge[maxn*5];
int cnt;
inline void add(int u,int to)
{
    edge[++cnt].to=to;
    edge[cnt].nxt=head[u];
    head[u]=cnt;
}
int que[maxn],qhead,qtail;
void topo()
{
    qhead=1,qtail=0;
    for(int i=1;i<=m;i++)
    {
        que[++qtail]=i;
        val[i].fz=val[i].fm=1;
    }
    while(qhead<=qtail)
    {
        int u=que[qhead++];
        for(int i=head[u];i;i=edge[i].nxt)
        {
            int to=edge[i].to;
            val[to]=val[to]+(val[u]/i128(chudu[u]));
            indu[to]--;
            if(!indu[to])
            {
                que[++qtail]=to;
            }
        }
    }
}
void write(i128 x)
{
    if(x>=10)
    {
        write(x/10);
    }
    putchar(int(x%10^48));
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        int di;
        scanf("%d",&di);
        int ai;
        for(int j=1;j<=di;j++)
        {
            scanf("%d",&ai);
            add(i,ai);
            indu[ai]++;
            chudu[i]++;
        }
    }
    topo();
    for(int i=1;i<=n;i++)
    {
        if(chudu[i]==0)
        {
            write(val[i].fz);
            putchar(' ');
            write(val[i].fm);
            putchar(10);
        }
    }
    return 0;
}