#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define f first
#define s second
#define pb push_back
#define pf push_front
#define in insert
#define elif else if
#define nl '\n'

typedef __int128 int128;
typedef long double ld;
#define  long  int64_t
#define ulong uint64_t
#define uint  uint32_t

using namespace std;
using namespace __gnu_pbds;
mt19937_64 rnd(chrono::steady_clock::now().time_since_epoch().count());

template <class T>
using oset = tree <T, null_type, less <T>, rb_tree_tag, tree_order_statistics_node_update>;

#define int long

const int N = 1e6 + 9, oo = 1e18;

vector <pair <int, int>> dp;
int n, p[N], a[N], b[N], l[N], r[N];

int32_t main() {
    cin.tie(0); ios::sync_with_stdio(0);
    cin >> n;
    for (int i = 1; i <= n; ++i)
        cin >> a[i] >> b[i];
    iota(r + 1, r + n + 1, 0);
    int mn = 0;
    for (int i = 1; i <= n; ++i) {
        cin >> p[i];
        if (p[i] == -1)
            continue;
        r[p[i]] = min(r[p[i]], i - 1);
        l[p[i] + 1] = max(l[p[i] + 1], i);
        mn = p[i];
    }
    for (int i = 2; i <= n; ++i)
        l[i] = max(l[i - 1], l[i]);
    for (int i = n - 1; i >= 1; --i)
        r[i] = min(r[i + 1], r[i]);

    vector <int> v;
    for (int i = 1; i <= n; ++i)
        if (i == 1 || l[i - 1] < l[i])
            v.pb(i);
    for (int i = 1; i < v.size(); ++i)
        assert(r[v[i] - 1] <= l[v[i]]);
    v.pb(n + 1);

    for (int i = 1; i <= n; ++i) {
        a[i] = a[i] + l[i] * b[i] + a[i - 1];
        r[i] -= l[i];
    }

//    for (int i = 1; i <= n; ++i)
//        cout << l[i] << " " << r[i] << nl;

    int prv = 0, ans = -oo;
    if (mn == 0)
        ans = 0;
    for (int i = 0; i + 1 < v.size(); ++i) {
//        cout << v[i] << ".." << v[i + 1] - 1 << nl;
        dp.pb({0, 0});
        for (int j = v[i]; j < v[i + 1]; ++j) {
            for (int k = 0; k < dp.size(); ++k)
                dp[k].s += b[j];
            int lst = r[j];
            while (dp.size() && dp.back().s < 0) {
                lst = dp.back().f;
                dp.pop_back();
            }
            dp.pb({lst, 0});
//            cout << j << ": ";
//            for (auto u : dp)
//                cout << u.f << " " << u.s << "   ";
//            cout << nl;
            if (j >= mn) {
                int mx = 0;
                for (int k = 0; k + 1 < dp.size(); ++k)
                    mx += dp[k].s * (dp[k + 1].f - dp[k].f);
//                cout << a[j] << " " << prv << " " << mx << nl;
                ans = max(ans, a[j] + prv + mx);
            }
        }
        prv = 0;
        for (int k = 0; k + 1 < dp.size(); ++k)
            prv += dp[k].s * (dp[k + 1].f - dp[k].f);
        dp.clear();
    }
    assert(ans > -oo);
    cout << ans;

//    int dp[n + 1][n];
//    for (int i = 0; i <= n; ++i)
//        for (int j = 0; j < n; ++j)
//            dp[i][j] = -oo;
//    dp[0][0] = 0;
//    int prA = 0, ans = -oo;
//    if (mn == 0)
//        ans = 0;
//    for (int i = 1; i <= n; ++i) {
//        prA += a[i];
//        int mx = -oo;
//        for (int j = 0; j < l[i]; ++j)
//            mx = max(mx, dp[i - 1][j]);
//        for (int j = l[i]; j <= r[i]; ++j) {
//            mx = max(mx, dp[i - 1][j]);
//            dp[i][j] = mx + b[i] * j;
//            if (i >= mn)
//                ans = max(ans, prA + dp[i][j]);
//        }
////        cout << i << " " << l[i] << " " << r[i] << ": ";
////        for (int j = l[i]; j <= r[i]; ++j)
////            cout << dp[i][j] << " ";
////        cout << nl;
////        vector <int> v;
////        for (int j = l[i] + 1; j <= r[i]; ++j)
////            v.pb(dp[i][j] - dp[i][j - 1]);
////        for (int j = 1; j < v.size(); ++j)
////            assert(v[j - 1] <= v[j]);
//    }
//    cout << ans;
}
/*
Если b[i] >= 0, dp[i] - строго возрастает
Если b[i] < 0, dp[i] ведёт себя странно

6
0 3
0 -2
0 2
0 -4
0 5
0 -3
-1 -1 -1 -1 -1 -1

1 0 0: 0
2 0 1: 0 -2
3 0 2: 0 2 4
4 0 3: 0 -2 -4 -8
5 0 4: 0 5 10 15 20
6 0 5: 0 2 4 6 8 5
20

Прибавить арифм. прогрессию до r[i]
Преф. максимум на всём массиве до r[i + 1]

6
0 3
0 -2
0 2
0 -4
0 5
0 -3
-1 3 -1 -1 5 -1
14

Разбил на блоки с одинаковым l.
dp неубывающий до r[i]. Если b[i] >= 0 - просто прибавляем её. Если b[i] < 0
*/
