#include <iostream>
#include <vector>
#include <algorithm>
#include <random>
#include <ctime>

using namespace std;


int to_digit(char c) {
    return c - '0';
}

char to_char(int x) {
    return '0' + x;
}

void trim(string& s) {
    for (int i=s.size()-1; i>=0; i--) {
        if (s[i] == '0') {
            s.pop_back();
        } else {
            break;
        }
    }
}

void add(string& s1, string& s2) {
    int mem = 0;
    int i = 0;
    for (; i<s1.size(); i++) {
        int res = to_digit(s1[i]) + mem;
        if (i<s2.size()) {
            res += to_digit(s2[i]);
        }
        
        s1[i] = to_char(res % 10);
        mem = res / 10;
    }
    
    for (; i<s2.size(); i++) {
        int res = to_digit(s2[i]) + mem;
        s1.push_back(to_char(res % 10));
        mem = res / 10;
    }
    
    if (mem != 0) {
        s1.push_back(to_char(mem));
    }
    trim(s1);
}

bool greater_or_equal(string& s1, string& s2) {
    if (s1.size() > s2.size()) {
        return true;
    }
    if (s1.size() < s2.size()) {
        return false;
    }
    
    for (int i=s1.size()-1; i>=0; i--) {
        if (s1[i] > s2[i]) {
            return true;
        }
        if (s1[i] < s2[i]) {
            return false;
        }
    }
    
    return true;
}

void sub(string& s1, string& s2) {
    int borr = 0;
    for (int i=0; i<s1.size(); i++) {
        int res = to_digit(s1[i]) + borr;
        borr = 0;
        
        if (i<s2.size()) {
            res -= to_digit(s2[i]);
        }
        
        if (res < 0) {
            borr = -1;
            res += 10;
        }
        s1[i] = to_char(res);
    }
    
    trim(s1);
}

pair<string, string> div_rem(string& s1, string& s2) {
    string div_res = "";
    string rem_res = s1;
    
    if (s1.size() < s2.size()) {
        return make_pair(div_res, rem_res);
    }
    int ten_pow=s1.size()-s2.size();
    
    string zeros = string(ten_pow, '0');
    for (int i=ten_pow; i>=0; i--) {
    //cout << "sizes " << zeros.size() << " " << s2.size() << endl;
        string substractor = zeros + s2;
        
        int count = 0;
        while (greater_or_equal(rem_res, substractor)) {
            count++;
            sub(rem_res, substractor);
        }
        div_res.push_back(to_char(count));
        zeros.pop_back();
    }
    
    reverse(div_res.begin(), div_res.end());
    trim(div_res);
    trim(rem_res);
    return make_pair(div_res, rem_res);
}

string mul_int(string& s, int v) {
    string mul_res;
    int mem = 0;
    
    for (int i=0; i<s.size(); i++) {
        int res = to_digit(s[i])*v + mem;
        
        mul_res.push_back(to_char(res % 10));
        mem = res/10;
    }
    
    while (mem != 0) {
        mul_res.push_back(to_char(mem % 10));
        mem /= 10;
    }
    
    trim(mul_res);
    return mul_res;
}

string mul(string& s1, string& s2) {
    string mul_res;
    int mem = 0;
    string zeros;
    
    for (int i=0; i<s2.size(); i++) {
        string multiplied_s1 = zeros + s1;
        string partial = mul_int(multiplied_s1, to_digit(s2[i]));
        add(mul_res, partial);
        zeros.push_back('0');
    }
    
    trim(mul_res);
    return mul_res;
}

bool randomBool() {
    return (rand() % 100) < 10;
}







void multiply_vec(vector<unsigned long long> &vec, unsigned long long num) {
    for (int i=0; i<vec.size(); i++) {
        vec[i] = vec[i] * num;
    }
}

void smultiply_vec(vector<string> &vec, string &num) {
    for (int i=0; i<vec.size(); i++) {
        vec[i] = mul(vec[i], num);
    }
}

unsigned long long gcd(unsigned long long a, unsigned long long b) {
    while (b != 0) {
        long b_val = b;
        b = a % b;
        a = b_val;        
    }
    
    return a;
}

string sgcd(string a, string b) {
    string one("1");
    while (greater_or_equal(b, one)) {
        string b_val = b;
        b = div_rem(a, b).second;
        a = b_val;        
    }
    
    return a;
}

vector<vector<int>> construct_max(int n) {
    vector<vector<int>> graph(1);
    srand(2137);
    
    for (int i=1; i<=n; i++) {
        vector<int> neighbors;
        
        
        if (i==77) {
            graph.push_back(neighbors);
            continue;
        }
        for (int j=i+1; j<=n; j++) {
            if (i==84) {
                continue;
            }
            if (randomBool()) {
                neighbors.push_back(j);
            }
        }
        graph.push_back(neighbors);
    }
    return graph;
}

int main() {
    int n;
    cin >> n;
    vector<vector<int>> graph(1);
    
    for (int i=0; i<n; i++) {
        int c;
        cin >> c;
        vector<int> neighbors;
        //cout << c << endl;
        for (int j=0; j<c; j++) {
            int v;
            cin >> v;
            neighbors.push_back(v);
        }
        
        //cout << i  << ": " << neighbors.size() << endl;
        graph.push_back(neighbors);
    }
    
    //cout << "15 "  << ": " << graph[15].size() << endl;
    
    // n=100;
    // graph = construct_max(100);
    
    // cout << 10;
    
    // for (auto vec: graph) {
    //     cout << vec.size() << " ";
    //     for (int i: vec) {
    //         cout << i << " ";
    //     }
    //     cout<<endl;
    // }
    
    vector<string> edges(n+1, "");
    for (int v: graph[1]) {
        edges[v] = "1";
    }
    // cout << "before computing "<< endl;
    //     for (int i=0; i<edges.size(); i++) {
    //         if (edges[i].size() == 0) {
    //             cout << 0 << " ";
    //         } else {
    //             cout << edges[i] << " ";
    //         }
    //     }
    // cout << endl;
    
    for (int next=2; next<=n; next++) {
        if (edges[next].size() == 0) { // no connection from start
            continue;
        }
        
        
        if (graph[next].size() == 0) { // leaf
            continue;
        }
        
        string outgoing_edges = to_string(graph[next].size());
        reverse(outgoing_edges.begin(), outgoing_edges.end());
        string incoming_edges = edges[next];
        
        
        string sgdc_res = sgcd(incoming_edges, outgoing_edges);
        string multiplier = div_rem(outgoing_edges, sgdc_res).first;
        smultiply_vec(edges, multiplier);


        string split = div_rem(edges[next], outgoing_edges).first;
        
        // cout << "inc " << incoming_edges << endl;
        // cout << "out " << outgoing_edges << endl;
        // cout << "gcd " << sgdc_res << endl;
        // cout << "mult " << multiplier << endl;
        // cout << "split " << split << endl;
        
        
        edges[next] = "";
        for (int outgoing : graph[next]) {
            add(edges[outgoing], split);
        }
        
        // cout << "after computing " << next << endl;
        // for (int i=0; i<edges.size(); i++) {
        //     if (edges[i].size() == 0) {
        //         cout << 0 << " ";
        //     } else {
        //         cout << edges[i] << " ";
        //     }
        // }
        // cout << endl;
    }
    
    string result = "";
    for (int i=1; i<edges.size(); i++) {
        add(result, edges[i]);
    }

    trim(result);
    if (result.size() == 0) {
        result = "1";
    }
    
    reverse(result.begin(), result.end());
    cout << result << endl;
    
    
    // string a("271368712638172");
    // reverse(a.begin(), a.end());
    // string b("777777777777777777777777");
    // reverse(b.begin(), b.end());
    
    // string g = sgcd(a, b);
    // reverse(g.begin(), g.end());
    // string m = mul(a, b);
    // reverse(m.begin(), m.end());
    // pair<string, string> dr = div_rem(a, b);
    // string d = dr.first;
    // reverse(d.begin(), d.end());
    // string r = dr.second;
    // reverse(r.begin(), r.end());
    // cout << "res " << d << " " << r << endl;
    // cout << "res " << g << endl;
    // cout << "res " << m;
    // cout << div_rem(a, b).first << " " << div_rem(a, b).second << endl;
    // cout << 213873612873 / 1273612763 << " " << 213873612873 % 1273612763 << endl;
    return 0;
}