#include <bits/stdc++.h>
using namespace std;
bool bfs(int numFruits, vector<vector<int>>& graph, vector<int>& pairU, vector<int>& pairV, vector<int>& dist) {
    queue<int> q;
    for (int u = 1; u <= numFruits; ++u) {
    if (pairU[u] == 0) {
    dist[u] = 0;
    q.push(u);
    } else {
    dist[u] = INT_MAX;
    }
    }
    dist[0] = INT_MAX;
    while (!q.empty()) 
    {
    int u = q.front();
    q.pop();
    if (dist[u] < dist[0]) {
    for (int v : graph[u]) {
    if (dist[pairV[v]] == INT_MAX) {
    dist[pairV[v]] = dist[u] + 1;
    q.push(pairV[v]);
    }
    }
    }
    }
    return dist[0] != INT_MAX;
}

bool dfs(int u, vector<vector<int>>& graph, vector<int>& pairU, vector<int>& pairV, vector<int>& dist) {
if (u != 0) {
for (int v : graph[u]) {
if (dist[pairV[v]] == dist[u] + 1 && dfs(pairV[v], graph, pairU, pairV, dist)) {
pairV[v] = u;
pairU[u] = v;
return true;
}
}
dist[u] = INT_MAX;
return false;
}
return true;
}
int hopcroftKarp(int numFruits, int numFriends, vector<vector<int>>& graph) {
    vector<int> pairU(numFruits + 1, 0);
    vector<int> pairV(numFriends + 1, 0);
    vector<int> dist(numFruits + 1);
    int matching = 0;
    while (bfs(numFruits, graph, pairU, pairV, dist)) {
    for (int u = 1; u <= numFruits; ++u) {
    if (pairU[u] == 0 && dfs(u, graph, pairU, pairV, dist)) {
    ++matching;
    }
    }
    }
    return matching;
}
int main() {
    int numOfFriends;
    cin >> numOfFriends;
    vector<vector<int>> preferences(numOfFriends + 1);
    for (int i = 1; i <= numOfFriends; ++i) {
    int count;
    cin >> count;
    preferences[i].resize(count);
    for (int j = 0; j < count; ++j) {
    cin >> preferences[i][j];
    }
    }
    int numRows, numCols;
    cin >> numRows >> numCols;
    int numFruits = numRows * numCols;
    vector<vector<int>> graph(numFruits + 1);
    for (int i = 1; i <= numOfFriends; ++i) {
    for (int fruit : preferences[i]) {
    if (fruit >= 1 && fruit <= numFruits) {
    graph[fruit].push_back(i);
    }
    }
    }
    cout << hopcroftKarp(numFruits, numOfFriends, graph) << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
int prime[100001] = {0};
int k[100001] = {0};
void Sieve() {
    for (int i = 1; i < 100001; i++)
        k[i] = i;

    for (int i = 2; i < 100001; i++) {
    if (prime[i] == 0) {
    for (int j = i; j < 100001; j += i) {
    prime[j] = 1;
    while (k[j] % (i * i) == 0)
    k[j] /= (i * i);
            }
        }
    }
}

int countPairs(int arr[], int n) {
    unordered_map<int, int> freq;
    for (int i = 0; i < n; i++) {
        freq[k[arr[i]]]++;
    }

    int sum = 0;
    for (auto i : freq) {
        sum += ((i.second - 1) * i.second) / 2;
    }

    return sum;
}

int main() {
    int n;
    cin >> n;
    int arr[n];
    for (int i = 0; i < n; i++) {
        arr[i] = i + 1;
    }

    Sieve();
    cout << n + 2 * countPairs(arr, n) << endl;

    return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll maxPyramidHeight(ll N, vector<ll>& arr) {
    sort(arr.begin(), arr.end());
    ll height = 0;
    ll blocks_used = 0;
    ll current_level_blocks = 1;
        while (blocks_used + current_level_blocks <= N) {
        blocks_used += current_level_blocks;
        height++;
        current_level_blocks++;
    }
    return height;
}

def bitByBit(input1, input2):
    n, a = input1, input2
    o = set()
    for i in range(n):
        c = 0
        for j in range(i, n):
            c |= a[j]
            o.add(c)
    m = float('inf')
    l = list(o)
    k = len(l)
    for i in range(k):
        for j in range(i + 1, k):
            m = min(m, l[i] ^ l[j])
    return m if m != float('inf') else 0

#include <bits/stdc++.h>
using namespace std;
int solve(int n) {
    if (n <= 0) return 1;  
    return (1 << (int)(log2(n - 1) + 1));
}
int main() {
    int N;
    cin >> N; 
    vector<int> A(N);
    for (int i = 0; i < N; i++) {
        cin >> A[i]; 
    }
    vector<int> squaredA(N);
    for (int i = 0; i < N; i++) {
        squaredA[i] = A[i] * A[i]; 
    }
    vector<int> setBits(N);
    int minSetBits = INT_MAX;
    int maxSetBits = INT_MIN;
    int X, Y;
    for (int i = 0; i < N; i++) {
    setBits[i] = __builtin_popcount(squaredA[i]);  
    if (setBits[i] < minSetBits) {
    minSetBits = setBits[i];
    Y = squaredA[i];  
    }
    if (setBits[i] > maxSetBits) 
    {
    maxSetBits = setBits[i];
    X = squaredA[i]; 
    }
    }
    int product = X * Y;
    int result = solve(product);
    cout << result << endl;
    return 0;
}