#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vl = vector<ll>;
template<class T> using vc = vector<T>;
template<class T> using vvc = vector<vector<T>>;

#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define repr(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repe(i, l, r) for (ll i = (l); i < (r); i++)
#define reper(i, l, r) for (ll i = (r)-1; i >= (l); i--)
#define repa(i,n) for (auto& i: n)

template<class T1, class T2> inline bool chmax(T1 &a, const T2 &b) {if (a<b) { a=b; return 1;} return 0;}
template<class T1, class T2> inline bool chmin(T1 &a, const T2 &b) {if (b<a) { a=b; return 1;} return 0;}
struct init{init(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);cerr<<fixed<<setprecision(15);}}init_;

#ifdef DEBUG
template <class T> void verr(const set<T> &st) { repa(a, st) cerr << a << " "; cerr << endl; }
template <class S, class T> void verr(const map<S, T> &mp) { repa(a, mp) cerr << "{" << a.first << ", " << a.second << "} "; cerr << endl; }
template <class S, class T, class N> void verr(const vector<pair<S,T>>& a, const N& n) { rep(i, n) cerr << "{" << a[i].first << ", " << a[i].second << "} "; cerr << endl; }
template <class T, class N> void verr(const vector<T>& a, const N& n) { rep(i, n) cerr << a[i] << " "; cerr << endl; }
ll dbgt = 1; void err() { cerr << "passed " << dbgt++ << endl; }
template<class H, class... T> void err(H&& h,T&&... t){ cerr<< h << (sizeof...(t)?" ":"\n") << flush; if(sizeof...(t)>0) err(forward<T>(t)...); }
#endif

const ll INF = 4e18;
const ld EPS = 1e-11;
const ld PI = acos(-1.0L);
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
//--------------------------------------------------------------------------------//
template <typename T>
struct MaxFlow {
    struct edge {
        int to, rev;
        T cap;
        edge(int to, int rev, T cap) : to(to), rev(rev), cap(cap) {}
    };

    vector<vector<edge>> G;
    int N;
    vector<int> level, iter;

    MaxFlow(int N) : N(N) { G.resize(N); }

    void add_edge(int from, int to, T cap) {
        G[from].emplace_back(to, G[to].size(), cap);
        G[to].emplace_back(from, (int)G[from].size() - 1, 0);
    }

   private:
    void bfs(int source) {
        level.assign(N, -1);
        queue<int> q;
        q.emplace(source);
        level[source] = 0;
        while (!q.empty()) {
            int v = q.front();
            q.pop();
            for (int i = 0; i < (int)G[v].size(); i++) {
                edge &e = G[v][i];
                if (e.cap > 0 && level[e.to] < 0) {
                    level[e.to] = level[v] + 1;
                    q.emplace(e.to);
                }
            }
        }
    }

    T dfs(int v, int sink, T flow) {
        if (v == sink) return flow;
        for (int &i = iter[v]; i < (int)G[v].size(); i++) {
            edge &e = G[v][i];
            if (e.cap > 0 && level[v] < level[e.to]) {
                T d = dfs(e.to, sink, min(e.cap, flow));
                if (d > 0) {
                    e.cap -= d;
                    G[e.to][e.rev].cap += d;
                    return d;
                }
            }
        }
        return 0;
    }

   public:
    // dinic法
    T build(int source, int sink) {
        T flow = 0;
        while (true) {
            bfs(source);
            if (level[sink] < 0) return flow;
            iter.assign(N, 0);
            T f;
            while ((f = dfs(source, sink, INF)) > 0) flow += f;
        }
    }
};

int main() {
    ll N;
    cin >> N;
    vl B(N), C(N);
    rep(i, N) cin >> B[i] >> C[i];

    ll M;
    cin >> M;
    ll ans = accumulate(all(B), 0ll) + accumulate(all(C), 0ll);
    MaxFlow<ll> mf(2 * N + 2);
    ll s = 2 * N, t = 2 * N + 1;
    rep(i, N) {
        mf.add_edge(s, 2 * i, B[i]);
        mf.add_edge(2 * i, 2 * i + 1, B[i] + C[i]);
        mf.add_edge(2 * i + 1, t, C[i]);
    }

    rep(i, M){
        ll d, e;
        cin >> d >> e;
        mf.add_edge(2 * d, 2 * e + 1, 1e9);

    }

    ans -= mf.build(s, t);
    cout << ans << endl;
}