#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) { return (ull)rng() % B; }
inline double time() {
    return static_cast<long double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count()) * 1e-9;
}

template <class S, S (*op)(S, S), S (*e)()> struct segtree {
    int n;
    vector<S> tree;
    segtree() : segtree(0) {}
    segtree(int n) : n(n), tree(vector<S>(n << 1, e())) {}
    segtree(const vector<S> &v) : n((int)v.size()) {
        tree.resize(n * 2);
        for (int i = 0; i < n; ++i) {
            tree[n + i] = v[i];
        }
        for (int i = n - 1; i >= 1; --i) {
            update(i);
        }
    }
    void update(int k) { tree[k] = op(tree[k << 1 | 0], tree[k << 1 | 1]); }
    S operator[](int i) { return tree[i + n]; }
    void set(int i, S x) {
        i += n;
        tree[i] = x;
        while (i >>= 1) {
            update(i);
        }
    }
    // [l,r)
    S query(int l, int r) {
        S sml = e(), smr = e();
        for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
            if (l & 1) sml = op(sml, tree[l++]);
            if (r & 1) smr = op(tree[--r], smr);
        }
        return op(sml, smr);
    }
};

using S = int;
S op(S a, S b) { return min(a, b); }
S e() { return 2e9; }

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int n;
    cin >> n;
    vector<vector<int>> v(n);
    vector<pair<int, int>> in(n), out(n);
    for (int i = 0; i < n; ++i) {
        int m;
        cin >> m;
        v[i].resize(m);
        for (int j = 0; j < m; ++j) {
            cin >> v[i][j];
        }
        sort(v[i].begin(), v[i].end());
        in[i] = {v[i][0], i};
        out[i] = {v[i].back(), i};
    }
    sort(in.begin(), in.end());
    sort(out.begin(), out.end());
    in.emplace_back(2e9, -1);
    out.emplace_back(2e9, -1);

    vector<pair<int, int>> pos(n);
    for (int i = 0; i < n; ++i) {
        pos[in[i].second].first = i;
        pos[out[i].second].second = i;
    }
    segtree<S, op, e> seg(n);

    int res = 0;
    set<int> st;
    for (int i = 0, j = 0; i < n or j < n;) {
        if (in[i].first <= out[j].first) {
            int idx = in[i].second;
            st.insert(idx);
            i += 1;
        } else {
            if (i != n) {
                cout << n << endl;
                return 0;
            }
            int idx = out[j].second;
            if (in[pos[idx].first].first == out[j].first) {
                // 元々1個しか入ってない
                res += 1;
                st.clear();
            } else {
                // 2個以上入ってる
                if (st.find(idx) == st.end()) {
                    res += 2;
                } else {
                    // 自分以降にinにあって、自分より早くoutにあるもの
                    // in_max <= k < out_min
                    int l = pos[idx].first;
                    int r = i;
                    int in_max = in[r - 1].first;
                    int out_min = seg.query(l, r);
                    bool one = false;
                    for (int k : v[idx]) {
                        if (in_max <= k and k < out_min) {
                            one = true;
                            break;
                        }
                    }
                    if (one) {
                        res += 1;
                        st.clear();
                    } else {
                        res += 2;
                        st.erase(idx);
                    }
                }
            }
            seg.set(pos[idx].first, out[j].first);
            j += 1;
        }
    }
    cout << res << endl;
}