#pragma GCC optimize("O3")

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define int long long
#define db long double
#define MX LLONG_MAX
#define MN LLONG_MIN
#define gcd __gcd
#define lcm(a, b) (a / gcd(a, b) * b)

using namespace std;
using namespace __gnu_pbds;
using ll = long long;

typedef tree<
int,
null_type,
less<int>,
rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;

const int N = 1e6 + 52;

int t[4 * N];

void build(int v, int tl, int tr, const vector<int>& a) {
    if (tl == tr) { t[v] = a[tl]; return; }

    int tm = (tl + tr) / 2;
    build(v * 2, tl, tm, a);
    build(v * 2 + 1, tm + 1, tr, a);

    t[v] = max(t[v * 2], t[v * 2 + 1]);
}

int get(int v, int tl, int tr, int l, int r) {
    if (l <= tl && tr <= r) return t[v];
    if (r < tl || tr < l) return 0;

    int tm = (tl + tr) / 2;
    return max(get(v * 2, tl, tm, l, r),
               get(v * 2 + 1, tm + 1, tr, l, r));
}

int32_t main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);

    int n;
    cin >> n;

    vector<int> a(n), b(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        cin >> b[i];
    }

    vector<int> p(n);
    for (int i = 0; i < n; i++) cin >> p[i];

    vector<int> pref_a(n + 1); pref_a[0] = 0;
    for (int i = 1; i <= n; i++) pref_a[i] = pref_a[i - 1] + a[i - 1];

    vector<int> pref_b(n + 1); pref_b[0] = 0;
    for (int i = 1; i <= n; i++) pref_b[i] = pref_b[i - 1] + a[i - 1] + b[i - 1] * (i - 1);

    vector<int> c(n);
    for (int i = 0; i < n; i++) c[i] = pref_b[i + 1];
    build(1, 0, n - 1, c);

    int ans = max(pref_a[n], 0LL);
    for (int i = 0; i < n - 1; i++) {
        int mx = get(1, 0, n - 1, i, n - 1);
        ans = max(ans, pref_a[i] + mx - pref_b[i]);
    }

    cout << ans;

//    int ans = 0;
//    vector<vector<int>> dp(n + 1, vector<int>(n, MN)); dp[0][0] = 0;
//    vector<int> mx(n + 1, 0);
//    for (int i = 1; i <= n; i++) {
//        int cur_mx = MN;
//        for (int t = 0; t < i; t++) {
//            dp[i][t] = a[i - 1] + b[i - 1] * t + mx[t];
//            ans = max(ans, dp[i][t]);
//            cur_mx = max(cur_mx, dp[i][t]);
//            mx[t] = cur_mx;
//        }
//        mx[i] = cur_mx;
//    }
//
//    cout << ans;
}
