#include <bits/stdc++.h>
#define turbo cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(0);

using namespace std;

const int base = 1000000000;
const int base_num = 9;

struct bignum {
    vector <int> num;
    int sign;

    int size() {
        if (num.empty())
            return 0;
        int res = (num.size() - 1) * base_num;
        int last = num.back();
        while(last) {
            res++; last /= 10;
        }
        return res;
    }

    string to_string() const {
        string res = "";
        if((*this).isZero())
            return "0";
        for (int i = num.size() - 1; i >= 0; i--) {
            string k = std::to_string(num[i]);
            if (i != num.size() - 1)
                while (k.size() < base_num)
                    k = "0" + k;
            res += k;
        }
        return res;
    }

    bignum() : sign(1) {}

    bignum (long long n) {
        *this = n;
    }

    void operator=(const bignum &v) {
		sign = v.sign;
		num = v.num;
	}

    void operator=(long long v) {
        sign = 1;
        num.clear();
        if (v < 0)
			sign = -1, v = -v;
		for (; v > 0; v = v / base)
			num.push_back(v % base);
    }

    bignum operator+(const bignum &v) const {
        if (sign == v.sign) {
			bignum res = v;
 
			for (int i = 0, carry = 0; i < (int) max(num.size(), v.num.size()) || carry; ++i) {
				if (i == (int) res.num.size())
					res.num.push_back(0);
				res.num[i] += carry + (i < (int) num.size() ? num[i] : 0);
				carry = res.num[i] >= base;
				if (carry)
					res.num[i] -= base;
			}
			return res;
		}
		return *this - (-v);
    }

    bignum operator-(const bignum &v) const {
        if (sign == v.sign) {
			if (abs() >= v.abs()) {
				bignum res = *this;
				for (int i = 0, carry = 0; i < (int) v.num.size() || carry; ++i) {
					res.num[i] -= carry + (i < (int) v.num.size() ? v.num[i] : 0);
					carry = res.num[i] < 0;
					if (carry)
						res.num[i] += base;
				}
				res.trim();
				return res;
			}
			return -(v - *this);
		}
		return *this + (-v);
    }

    bignum operator-() const {
		bignum res = *this;
		res.sign = -sign;
		return res;
	}

    bignum abs() const {
		bignum res = *this;
		res.sign *= res.sign;
		return res;
	}

    bool operator<(const bignum &v) const {
		if (sign != v.sign)
			return sign < v.sign;
		if (num.size() != v.num.size())
			return num.size() * sign < v.num.size() * v.sign;
		for (int i = num.size() - 1; i >= 0; i--)
			if (num[i] != v.num[i])
				return num[i] * sign < v.num[i] * sign;
		return false;
	}

    bool operator>(const bignum &v) const {
		return v < *this;
	}
	bool operator<=(const bignum &v) const {
		return !(v < *this);
	}
	bool operator>=(const bignum &v) const {
		return !(*this < v);
	}
	bool operator==(const bignum &v) const {
		return !(*this < v) && !(v < *this);
	}
	bool operator!=(const bignum &v) const {
		return *this < v || v < *this;
	}

    void operator+=(const bignum &v) {
        *this = *this + v;
    }

    void operator-=(const bignum &v) {
        *this = *this - v;
    }

    bignum operator*(int v) const {
        bignum res = *this;
        res *= v;
        return res;
    }

	bignum operator*(long long v) const {
		bignum res = *this;
		res *= v;
		return res;
	}

    void operator*=(long long v) {
		if (v < 0)
			sign = -sign, v = -v;
		if(v > base){
			*this = *this * (v / base) * base + *this * (v % base);
			return ;
		}
		for (int i = 0, carry = 0; i < (int) num.size() || carry; ++i) {
			if (i == (int) num.size())
				num.push_back(0);
			long long cur = num[i] * (long long) v + carry;
			carry = (int) (cur / base);
			num[i] = (int) (cur % base);
		}
		trim();
	}

    friend pair<bignum, bignum> divmod(const bignum &a1, const bignum &b1) {
		int norm = base / (b1.num.back() + 1);
		bignum a = a1.abs() * norm;
		bignum b = b1.abs() * norm;
		bignum q, r;
		q.num.resize(a.num.size());
 
		for (int i = a.num.size() - 1; i >= 0; i--) {
			r *= base;
			r += a.num[i];
			int s1 = r.num.size() <= b.num.size() ? 0 : r.num[b.num.size()];
			int s2 = r.num.size() <= b.num.size() - 1 ? 0 : r.num[b.num.size() - 1];
			int d = ((long long) base * s1 + s2) / b.num.back();
			r -= b * d;
			while (r < 0)
				r += b, --d;
			q.num[i] = d;
		}
 
		q.sign = a1.sign * b1.sign;
		r.sign = a1.sign;
		q.trim();
		r.trim();
		return make_pair(q, r / norm);
	}

    bignum operator/(const bignum &v) const {
        return divmod(*this, v).first;
    }

    bignum operator%(const bignum &v) const {
        return divmod(*this, v).second;
    }

    void operator/=(int v) {
		if (v < 0)
			sign = -sign, v = -v;
		for (int i = (int) num.size() - 1, rem = 0; i >= 0; --i) {
			long long cur = num[i] + rem * (long long) base;
			num[i] = (int) (cur / v);
			rem = (int) (cur % v);
		}
		trim();
	}

    bignum operator/(int v) const {
		bignum res = *this;
		res /= v;
		return res;
	}

    void trim() {
		while (!num.empty() && !num.back())
			num.pop_back();
		if (num.empty())
			sign = 1;
	}

    bool isZero() const {
        return num.empty() || (num.size() == 1 && !num[0]);
    }

    friend bignum gcd(const bignum &a, const bignum &b) {
		return b.isZero() ? a : gcd(b, a % b);
	}

};

const int N = 105;

vector <int> graph[N];
bignum visited[N];

int n;


void readinput() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        int k, x;
        cin >> k;
        for (int j = 0; j < k; j++) {
            cin >> x;
            graph[i].push_back(x);
        }
    }
}

void reset () {
    for (int i = 1; i <= n; i++)
        visited[i] = 0;
}

void DFS(int v) {
    for (auto &u : graph[v])
        visited[u] += visited[v] / graph[v].size();
}

int mygcd (int a, bignum b) {
    multiset <int> rozklad;
    int d = 2;
    while (a > 1) {
        if (a % d == 0) {
            rozklad.insert(d);
            a /= d;
        }
        else
            d++;
    }
    int res = 1;
    for (auto &i : rozklad) {
        if (b % i == 0) {
            b /= i;
            res *= i;
        }
    }
    return res;
}

bignum solve(bignum x) {
    reset();
    visited[1] = x;
    for (int i = 1; i <= n; i++)
        DFS(i);
    for (int i = 1; i <= n; i++) {
        if (!graph[i].size())
            continue;
        if (!(visited[i] % bignum(graph[i].size())).isZero())
            return solve(x * ((int) graph[i].size() / mygcd(graph[i].size(), visited[i])));
    }
    return x;
}

int main() {
    turbo;
    readinput();
    string res = (solve(bignum(1))).to_string();
    cout << res << "\n";
    return 0;
}