#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
using vl = vector<ll>;
template <class T> using vec = vector<T>;
template <class T> using vv = vec<vec<T>>;
template <class T> using vvv = vv<vec<T>>;
template <class T> using minpq = priority_queue<T, vec<T>, greater<T>>;
#define rep(i, r) for(ll i = 0; i < (r); i++)
#define reps(i, l, r) for(ll i = (l); i < (r); i++)
#define rrep(i, l, r) for(ll i = (r) - 1; i >= (l); i--)
#define all(a) (a).begin(), (a).end()
#define sz(a) (ll)(a).size()
template<typename T>
bool chmax(T &a, const T& b) { return a < b ? a = b, true : false; }
template <typename T>
bool chmin(T &a, const T& b) { return a > b ? a = b, true : false; }
ll modmul(ll a, ll b, ll mod) {
	ll ret = a * b - mod * ll(1.L / mod * a * b);
	return ret + mod * (ret < 0) - mod * (ret >= mod);
}
ll modpow(ll a, ll b, ll mod) {
	ll ans = 1;
	for (; b; a = modmul(a, a, mod), b /= 2)
		if (b & 1) ans = modmul(ans, a, mod);
	return ans;
}

using ull = unsigned long long;

int solve() {
    ll n, k;
    cin >> n >> k;
    // vv<ll> dp(n, vl(3, 0));
    // dp[0][0] = 1;
    // reps(i, 1, n) {
    //     dp[i][0] = dp[i-1][0] + dp[i-1][1];
    //     dp[i][1] = dp[i-1][0];
    //     dp[i][2] = dp[i-1][1] + dp[i-1][2];
    // }
    // auto sub_solve = [&](auto&& f, ll n, ll k) -> string {
    //     // 先頭がAのとき
    //     ll a_cnt = 1LL<<(n-1);
    //     // MMAを含まないのは何通り?
    //     ll a_not_cnt = dp[n-1][0] + dp[n-1][1] + dp[n-1][2];
    //     a_cnt -= a_not_cnt;
    //     if(a_cnt >= k) return "A" + f(f, n-1, k);
    //     k -= a_cnt;

    //     // ll ma_cnt = 1LL<<(n-2);
    //     // ll ma_not_cnt = dp[n-1][0] + dp[n-1][1] + dp[n-1][2];
    //     // ma_cnt -= ma_not_cnt;
    //     // if(ma_cnt >= k) return "MA" + f(f, n-2, k);
    //     // k -= ma_cnt;
    //     // return "MM" + f(f, n-2, k)
    // };
    // cout << sub_solve(sub_solve, n, k) << endl;

    // i文字の文字列であって、
    // vvv<ll> dp(n, vv<ll>(3, vl(2, 0)));
    // dp[0][0][0] = 1;
    // reps(i, 1, n) {
    //     dp[i][0] = dp[i-1][0] + dp[i-1][1];
    //     dp[i][1] = dp[i-1][0];
    //     dp[i][2] = dp[i-1][1] + dp[i-1][2];
    // }


    // return 0;
}

int solveG() {
    ll n, a, b;
    cin >> n >> a >> b;
    n--;
    if(a > b) swap(a, b);
    n %= (a + b)*2;
    // if()


    // auto sub_solve = [&](ll n){
    //     if((n+a-1)/a%2 == 0) return 0;
    //     else return 1;
    // };
    // ll grundy;
    // if(n < b) {
    //     grundy = sub_solve(n);
    // } else {
    //     if(sub_solve(n-b) == 1) grundy = 0;
    //     else 
    // }
    return 0;
}

int solveH() {
    ll l;
    cin >> l;
    if(l % 2 == 0) {
        ll a = (l/2)*(l/2) + 1, b = (l/2)*(l/2) - 1;
        assert(a * a - b * b == l * l);
        cout << a << " " << b << " " << l << endl;
    } else {
        ll k = l / 2;
        ll a = 2 * k * (k+1) + 1, b = 2 * k * (k+1);
        assert(a * a == b * b + l * l);
        cout << a << " " << b << " " << l << endl;
    }
    return 0;
}

int solveI() {
    ll n;
    cin >> n;
    vec<pll> ab(n);
    rep(i, n) cin >> ab[i].first >> ab[i].second;
    vv<ll> dp(n, vl(n+1, -1));
    dp[n-1][1] = ab[n-1].second;
    rrep(i, 0, n-1) {
        auto [a, b] = ab[i];
        reps(j, 1, n+1) {
            if(dp[i+1][j] >= 0)
                chmax(dp[i][j], dp[i+1][j] + a * j);
            if(dp[i+1][j-1] >= 0)
                chmax(dp[i][j], dp[i+1][j-1] + b);
        }
    }
    ll ans = 0;
    rep(j, n+1) chmax(ans, dp[0][j]);
    // rep(i, n) {
    //     rep(j, n+1) {
    //         cerr << dp[i][j] << " ";
    //     }
    //     cerr << endl;
    // }
    cout << ans << endl;
    return 0;
}

int main() {
	ll T = 1;
	cout << fixed << setprecision(16);
	// cin >> T;
	while (T--) solveI();
}