#include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/rope>

using namespace std;
// using namespace __gnu_pbds;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef long double ld;

template <class T>

using VV = vector<vector<T>>;

using VI = vector<int>;
using VVI = vector<vector<int>>;

using VL = vector<long long>;
using VVL = vector<vector<long long>>;

using VC = vector<char>;
using VVC = vector<vector<char>>;

using VB = vector<bool>;
using VVB = vector<vector<bool>>;

using VD = vector<double>;
using VVD = vector<vector<double>>;

using PII = pair<int, int>;
using PLL = pair<long long, long long>;
using PIL = pair<int, long long>;
using PLI = pair<long long, int>;

using VPII = vector<pair<int, int>>;
using VPLL = vector<pair<long long, long long>>;

#define LINE '\n'
#define SPACE ' '
#define PB push_back
#define FOR(i, a, b) for (int i = (a); i < (int(b)); i++)
#define FORE(i, a, b) for (int i = (a); i <= (int)((b)); i++)
#define ALL(x) x.begin(), x.end()
#define RALL(x) x.rbegin(), x.rend()
#define sq(a) ((a) * (a))
#define sz(x) ((int)x.size())

#define fastio()                      \
    ios_base::sync_with_stdio(false); \
    cin.tie(nullptr);                 \
    cout.tie(nullptr)
#define debug(x) cerr << #x << " = " << x << endl;

const ll MOD = 1e9 + 7;

namespace debug_internal
{

    void print_value(const string &x) { cerr << '"' << x << '"'; }
    void print_value(const char *x) { cerr << '"' << x << '"'; }
    void print_value(char x) { cerr << '\'' << x << '\''; }
    void print_value(bool x) { cerr << (x ? "true" : "false"); }

    void print_value(short x) { cerr << x; }
    void print_value(unsigned short x) { cerr << x; }
    void print_value(int x) { cerr << x; }
    void print_value(unsigned x) { cerr << x; }
    void print_value(long x) { cerr << x; }
    void print_value(unsigned long x) { cerr << x; }
    void print_value(long long x) { cerr << x; }
    void print_value(unsigned long long x) { cerr << x; }
    void print_value(float x) { cerr << x; }
    void print_value(double x) { cerr << x; }
    void print_value(long double x) { cerr << x; }

#if defined(__SIZEOF_INT128__)
    void print_value(__int128 x)
    {
        if (x == 0)
        {
            cerr << 0;
            return;
        }
        if (x < 0)
        {
            cerr << '-';
            x = -x;
        }
        string s;
        while (x)
        {
            s.push_back(char('0' + x % 10));
            x /= 10;
        }
        reverse(s.begin(), s.end());
        cerr << s;
    }
    void print_value(unsigned __int128 x)
    {
        if (x == 0)
        {
            cerr << 0;
            return;
        }
        string s;
        while (x)
        {
            s.push_back(char('0' + x % 10));
            x /= 10;
        }
        reverse(s.begin(), s.end());
        cerr << s;
    }
#endif

    template <class A, class B>
    void print_value(const pair<A, B> &p);

    template <class... Ts>
    void print_value(const tuple<Ts...> &t);

    template <class T>
    auto print_value(const T &v) -> decltype(begin(v), end(v), void())
    {
        cerr << '{';
        bool first = true;
        for (const auto &x : v)
        {
            if (!first)
                cerr << ", ";
            first = false;
            print_value(x);
        }
        cerr << '}';
    }

    template <class A, class B>
    void print_value(const pair<A, B> &p)
    {
        cerr << '(';
        print_value(p.first);
        cerr << ", ";
        print_value(p.second);
        cerr << ')';
    }

    template <size_t I = 0, class... Ts>
    void print_tuple(const tuple<Ts...> &t)
    {
        if constexpr (I < sizeof...(Ts))
        {
            if constexpr (I)
                cerr << ", ";
            print_value(get<I>(t));
            print_tuple<I + 1>(t);
        }
    }

    template <class... Ts>
    void print_value(const tuple<Ts...> &t)
    {
        cerr << '(';
        print_tuple(t);
        cerr << ')';
    }

    void split_names(const string &s, vector<string> &out)
    {
        string cur;
        int bal = 0;
        for (char c : s)
        {
            if (c == ',' && bal == 0)
            {
                size_t l = 0, r = cur.size();
                while (l < r && isspace((unsigned char)cur[l]))
                    ++l;
                while (r > l && isspace((unsigned char)cur[r - 1]))
                    --r;
                out.push_back(cur.substr(l, r - l));
                cur.clear();
            }
            else
            {
                if (c == '(' || c == '[' || c == '{' || c == '<')
                    ++bal;
                if (c == ')' || c == ']' || c == '}' || c == '>')
                    --bal;
                cur += c;
            }
        }
        size_t l = 0, r = cur.size();
        while (l < r && isspace((unsigned char)cur[l]))
            ++l;
        while (r > l && isspace((unsigned char)cur[r - 1]))
            --r;
        if (l < r)
            out.push_back(cur.substr(l, r - l));
    }

    void print_named(const vector<string> &, int) { cerr << '\n'; }

    template <class Head, class... Tail>
    void print_named(const vector<string> &names, int idx, Head &&H, Tail &&...T)
    {
        if (idx)
            cerr << " | ";
        cerr << names[idx] << " = ";
        print_value(H);
        if constexpr (sizeof...(T))
            print_named(names, idx + 1, forward<Tail>(T)...);
        else
            cerr << '\n';
    }

    template <class T>
    decltype(auto) tee_impl(const char *expr, T &&x, const char *file, int line)
    {
        cerr << '[' << file << ':' << line << "] " << expr << " = ";
        print_value(x);
        cerr << '\n';
        return forward<T>(x);
    }

} // namespace debug_internal

#define DBG(...)                                             \
    do                                                       \
    {                                                        \
        vector<string> _names;                               \
        debug_internal::split_names(#__VA_ARGS__, _names);   \
        cerr << "[L" << __LINE__ << "] ";                    \
        debug_internal::print_named(_names, 0, __VA_ARGS__); \
    } while (0)

#define TEE(x) debug_internal::tee_impl(#x, (x), __FILE__, __LINE__)

template <class T>
inline void maxi(T &a, T b)
{
    a = max(a, b);
}

template <class T>
inline void mini(T &a, T b)
{
    a = min(a, b);
}

template <class T>
inline void addi(T &a, T b)
{
    a = (a + b) % MOD;
}

template <class T>
inline void subi(T &a, T b)
{
    a = (a - b + MOD) % MOD;
}

template <class T>
inline T add(T a, T b)
{
    return (a + b) % MOD;
}

template <class T>
inline T sub(T a, T b)
{
    return (a - b + MOD) % MOD;
}

template <class T>
inline T mul(T a, T b)
{
    return ((a % MOD) * (b % MOD)) % MOD;
}

constexpr ll binpow(ll a, ll b, ll mod)
{
    ll res = 1;
    while (b > 0)
    {
        if (b & 1)
        {
            res = (res * a) % mod;
        }
        a = (a * a) % mod;
        b >>= 1;
    }

    return res;
}

const int INF = 1e9;

const int MAX_N = 1e6 + 3;


void solve()
{
    VVI g(MAX_N);
    VI dp(MAX_N, 0);
    VI par(MAX_N, -1);
    VVI at(MAX_N);

    int k, n1;
    cin >> k >> n1;

    VI pre;
    int id = 1;
    FOR(i, 0, n1)
    {
        at[1].PB(id);
        pre.PB(id++);
        
    }

    
    FOR(i, 2, k + 1)
    {
        int ni;
        cin >> ni;
           VI cur;
        FOR(j, 0, ni)
        {
            int a;
            cin >> a;

            cur.PB(id);
            at[i].PB(id);
            if (a != 0)
            {
                par[id] = pre[a - 1];
            }
            id++;
        }
        pre = cur;
    }


    for(int i = id-1; i >= 1; i--) {
        maxi(dp[i], 1);
        if(par[i] != -1) {
            dp[par[i]] += dp[i];
        }
    }

    int ans = 0;
    FOR(i, 1, k + 1) {
        int d = 0;
        for(auto v : at[i]) d += dp[v];
        maxi(ans, d);
    }
    cout << ans << LINE;
}

int main()
{
    fastio();

    int t = 1;
    // cin >> t;

    while (t--)
        solve();
}