#include <bits/stdc++.h>
using namespace std;

const int MAXN = 202020;
int n, src, snk, N1, N2, N3;
vector<int> G[3][3][MAXN / 4];
set<pair<int, int>> S1, S2, S3;
map<array<int, 3>, int> mp;

int f(int x, int y, int z) {
    if (mp.find({x, y, z}) == mp.end()) {
        mp[{x, y, z}] = 1 + mp.size();
    }
    return mp[{x, y, z}];
}

int col[MAXN];
vector<int> gph[MAXN];

bool flag = true;
vector<int> vec;
void dfs(int v, int z) {
    if (col[v]) {
        if (col[v] != z) {
            flag = false;
        }
        return;
    }
    vec.push_back(v);
    col[v] = z;
    for (int x : gph[v]) {
        dfs(x, z ^ 3);
    }
}
struct edge {
    int u, v, c, dual;
};
vector<edge> adj[MAXN];
void add_edge(int u, int v) {
    adj[u].push_back({u, v, 1, (int)adj[v].size()});
    adj[v].push_back({v, u, 0, (int)adj[u].size() - 1});
}

int dist[MAXN];
int sp[MAXN];

int flow(int v, int minf) {
    if (v == snk) return minf;
    while (sp[v] < adj[v].size()) {
        auto &e = adj[v][sp[v]++];
        if (e.c == 0 || dist[e.v] != dist[v] + 1) continue;
        int f = flow(e.v, min(minf, e.c));
        if (f != 0) {
            e.c -= f;
            adj[e.v][e.dual].c += f;
            return f;
        }
    }
    return 0;
}
int run() {
    for (int i = 0; i <= n + 2; i++) dist[i] = 1e9;
    queue<int> q; 
    q.push(src); 
    dist[src] = 0;
    while (!q.empty()) {
        int v = q.front(); q.pop();
        for (auto e : adj[v]) if (e.c > 0) {
            if (dist[e.v] == 1e9) {
                dist[e.v] = dist[v] + 1;
                q.push(e.v);
            }
        }
    }
    for (int i = 0; i <= n + 2; i++) sp[i] = 0;
    int res = 0;
    int f = flow(src, 1e9);
    while (f > 0) {
        res += f;
        f = flow(src, 1e9);
    }
    return res;
}
int main() {
    cin.tie(0); ios_base::sync_with_stdio(0);
    cin >> N1 >> N2 >> N3;
    for (int i = 1; i <= N1; i++) {
        int n; cin >> n;
        for (int j = 0; j < n; j++) {
            int x; cin >> x;
            S1.insert({i, x});
            G[0][1][i].push_back(x);
            G[1][0][x].push_back(i);
        }
    }
    for (int i = 1; i <= N1; i++) {
        int n; cin >> n;
        for (int j = 0; j < n; j++) {
            int x; cin >> x;
            S2.insert({i, x});
            G[0][2][i].push_back(x);
            G[2][0][x].push_back(i);
        }
    }
    for (int i = 1; i <= N2; i++) {
        int n; cin >> n;
        for (int j = 0; j < n; j++) {
            int x; cin >> x;
            S3.insert({i, x});
            G[1][2][i].push_back(x);
            G[2][1][x].push_back(i);
        }
    }
    for (auto [x, y] : S1) {
        vector<int> v;
        for (int z : G[0][2][x]) for (int z1 : G[1][2][y]) {
            if (z == z1) v.push_back(f(x, y, z));
        }
        for (int i = 0; i < (int)v.size() - 1; i++) {
            int u1 = v[i];
            int u2 = v[i + 1];
            gph[u1].push_back(u2);
            gph[u2].push_back(u1);
        }
    }
    for (auto [x, z] : S2) {
        vector<int> v;
        for (int y : G[0][1][x]) for (int y1 : G[2][1][z]) {
            if (y == y1) v.push_back(f(x, y, z));
        }
        for (int i = 0; i < (int)v.size() - 1; i++) {
            int u1 = v[i];
            int u2 = v[i + 1];
            gph[u1].push_back(u2);
            gph[u2].push_back(u1);
        }
    }
    for (auto [y, z] : S3) {
        vector<int> v;
        for (int x : G[1][0][y]) for (int x1 : G[2][0][z]) {
            if (x == x1) v.push_back(f(x, y, z));
        }
        for (int i = 0; i < (int)v.size() - 1; i++) {
            int u1 = v[i];
            int u2 = v[i + 1];
            gph[u1].push_back(u2);
            gph[u2].push_back(u1);
        }
    }
    int ans = 0;
    n = mp.size();
    for (int i = 1; i <= n; i++) {
        if (col[i]) continue;
        dfs(i, 1);
        if (!flag) {
            ans += (vec.size() + 1) / 2;
            for (int x : vec)
                col[x] = 3;
            vec.clear();
            flag = true;
        }
    }
    src = n + 1; 
    snk = n + 2;
    for (int i = 1; i <= n; i++) {
        if (col[i] == 1) {
            add_edge(src, i);
            for (int x : gph[i]) add_edge(i, x);
        }
        else add_edge(i, snk);
    }
    int f = run();
    while (f > 0) {
        ans += f;
        f = run();
    }
    cout << n - ans;
}