#include <bits/stdc++.h>

using i64 = long long;
using u32 = unsigned;
using u64 = unsigned long long;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int g;
    std::cin >> g;

    std::map<int, int> ord;
    int tot = 0;

    auto add = [&](int x) -> void {
        if (!ord.count(x)) {
            ord[x] = tot++;
        }
    };  

    std::map<int, int> map;
    for (int i = 0; i < g; ++i) {
        int t, u;
        std::cin >> t >> u;
        add(t);
        map[t] += u;
    }

    int n;
    std::cin >> n;

    std::vector<std::pair<int, int>> can(1E5 + 1);
    std::vector<std::set<std::pair<int, int>>> set(1E5 + 1);
    std::vector<std::vector<std::pair<int, int>>> get(1E5 + 1);
    std::set<std::pair<int, int>> tset;
    for (int i = 0; i < n; ++i) {
        int m;
        std::cin >> m;

        can[i].first = m;
        int cnt = 0;
        std::vector<int> a(m), b(m);
        for (int j = 0; j < m; ++j) {
            std::cin >> a[j] >> b[j];
            add(a[j]);
            cnt += map[a[j]] >= b[j];
        }
        can[i].second = cnt;

        int k;
        std::cin >> k;

        for (int j = 0; j < k; ++j) {
            int c, d;
            std::cin >> c >> d;
            add(c);
            get[i].emplace_back(c, d);
        }
        if (cnt != m) {
            for (int j = 0; j < m; ++j) {
                if (map[a[j]] < b[j]) {
                    int y = ord[a[j]];
                    set[y].emplace(b[j], i);
                }
            }
            tset.emplace(0, i);
        } else {
            tset.emplace(1, i);
        }
    }

    // for (auto [i, j] : tmap) {
    //     map[i] += j;
    //     int y = disc.find(i);
    //     while (!set[y].empty() && map[i] >= set[y].begin()->first) {
    //         auto [u, v] = *set[y].begin();
    //         set[y].erase({u, v});


    //     }
    // }

    while (!tset.empty() && tset.rbegin()->first) {
        auto [_, i] = *tset.rbegin();
        tset.erase({_, i});

        for (auto [c, d] : get[i]) {
            add(c);
            int y = ord[c];
            map[c] += d;
            while (!set[y].empty() && map[c] >= set[y].begin()->first) {
                auto [u, v] = *set[y].begin();
                set[y].erase({u, v});

                if (++can[v].second == can[v].first) {
                    auto [i1, j1] = *tset.find({0, v});
                    tset.erase({i1, j1});
                    tset.emplace(1, v);
                }
            }
        }
    }

    std::cout << n - tset.size();

    return 0;
}