#include <bits/stdc++.h>

#define ll long long
#define fors(u, n, s) for(ll u=(s); u < (n); u++)
#define foru(u, n) fors(u, n, 0)
#define ir(a, b, x) (((a) <= (x)) && ((x) <= (b)))
#define vec vector
#define pb push_back

#define last(x) (x[x.size()-1])

using namespace std;

#define D 1000000000LL

struct arb_pre{
    vec<ll> digits;

    arb_pre to_arb(ll x) const{
        arb_pre output;
        output.digits.pb(x);
        return output;
    }

    arb_pre operator+(const arb_pre rhs) const{
        ll carry=0;
        arb_pre output;
        foru(i, max(digits.size(), rhs.digits.size())){
            output.digits.pb(carry);
            if(i<digits.size()) last(output.digits) += digits[i];
            if(i<rhs.digits.size()) last(output.digits) += rhs.digits[i];
            carry=last(output.digits)/D;
            last(output.digits)=last(output.digits)%D;
        }
        if(carry!=0) output.digits.pb(carry);
        return output;
    }

    arb_pre operator-(const arb_pre rhs) const{
        ll carry=0;
        arb_pre output;
        foru(i, max(digits.size(), rhs.digits.size())){
            output.digits.pb(carry); carry=0;
            if(i<digits.size()) last(output.digits) += digits[i];
            if(i<rhs.digits.size()) last(output.digits) -= rhs.digits[i];
            while(last(output.digits)<0) {last(output.digits)+=D; carry--;}
            //last(output.digits)=last(output.digits)%D;
        }
        if(carry!=0) cout << "PANIK" << endl;;
        while(last(output.digits)==0) output.digits.resize(output.digits.size()-1);
        return output;
    }

    void operator*(int rhs){
        ll carry=0;
        foru(i, digits.size()){
            digits[i]*=rhs;
            digits[i]+=carry;
            carry=digits[i]/D;
            digits[i]=digits[i]%D;
        }
        while(carry!=0){
            digits.pb(carry%D);
            carry/=D;
        }
    }

    arb_pre half(){
        arb_pre output;
        output.digits=digits;
        ll carry=0;
        for(int i=digits.size()-1; i>=0; i--){
            output.digits[i]+=carry*D;
            carry=(output.digits[i] & 1);
            output.digits[i]=output.digits[i]/2;
        }
        while(last(output.digits)==0) output.digits.resize(output.digits.size()-1);
        return output;
    }

    bool operator==(const arb_pre rhs) const{
        if(digits.size()!=rhs.digits.size()) return false;
        for(int i=digits.size()-1;i>=0;i--){
            if(digits[i]!=rhs.digits[i]) return false;
        }
        return true;
    }

    void read(){
        arb_pre output;
        char c; cin >> c;
        while(!ir('0', '9', c)) c=getchar();;
        while(ir('0', '9', c)){
            output*10;
            output = output + to_arb(c-'0');
            c=getchar();
        }
        while(last(output.digits)==0) output.digits.resize(output.digits.size()-1);
        digits=output.digits;
    }

    void print(){
        for(int i=digits.size()-1; i>=0; i--){
            string out = to_string(digits[i]);
            if(i!=digits.size()-1) foru(_i, 9-out.length()) cout << "0";
            cout << out;
        }
    }

    int operator%(const int b) const{
        ll ans=0;
        for(int i=digits.size()-1; i>=0;i--){
            ans*=D;
            ans+=digits[i]%b;
            ans=ans%b;
        }
        return ans;
    }

    arb_pre operator/(const int b) const{
        arb_pre a; a.digits=digits;
        int carry=0;
        for(int i=a.digits.size()-1; i>=0;i--){
            a.digits[i]+=carry*D;
            carry=a.digits[i]%b;
            a.digits[i]=a.digits[i]/b;
            while(a.digits[i]>=D){
                if(i==a.digits.size()-1) a.digits.pb(0);
                a.digits[i+1]++;
                a.digits[i]-=D;
            }
        }
        return a;
    }
};

arb_pre to_arb(ll x){
    arb_pre output;
    output.digits.pb(x);
    while(last(output.digits)==0) output.digits.resize(output.digits.size()-1);
    return output;
}

vec<int> primes{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
struct frac{
    arb_pre numer;
    int denom[25];

    void shorten(){
        foru(i, 25){
            while(denom[i]>0 && numer%primes[i]==0){
                numer=numer/primes[i];
                denom[i]--;
            }
        }
    }

     void operator/(int b) {
        foru(i, 25){
            while(b%primes[i]==0){
                denom[i]++; b/=primes[i];
            }
            if(b==1){shorten(); return;}
        }
     }

     void operator+(frac b){
        foru(i, 25){
            foru(_i, denom[i]) b.numer*primes[i];
            foru(_i, b.denom[i]) numer*primes[i];
            denom[i]+=b.denom[i];
        }
        numer = numer + b.numer;
        shorten();
     }
};

#define N 100

vec<int> edges[N];

int output[25];

frac val[N];

int main()
{
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int n; cin >> n;
    foru(i, n){
        int t; cin >> t;
        foru(_i, t){
            int j; cin >> j; j--;
            edges[i].pb(j);
        }
    }


    /*int n; cin >> n;
    srand(n);
    n=100;
    foru(i, n){
        fors(j, n, i+1) if(rand() & 1)edges[i].pb(j);
    }*/

    foru(i, 25) output[i]=0;

    foru(i, n) foru(j, 25) val[i].denom[j]=0;
    foru(i, n) val[i].numer=to_arb(0);
    val[0].numer=to_arb(1);

    foru(i, n){
        if(edges[i].size()==0) continue;
        if(val[i].numer==to_arb(0)) continue;
        val[i]/edges[i].size();
        foru(j, 25) output[j]=max(output[j], val[i].denom[j]);
        for(auto j : edges[i]){
            val[j]+val[i];
        }
    }

    arb_pre x = to_arb(1);
    foru(i, 25) foru(_i, output[i]) x*primes[i];
    x.print();

    return 0;
}