#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>
#include <map>

int n = 0;
vector<int> que;
map<long long, int> mp;
vector<long long> sum;
vector<pair<long long, long long>> ab;
int l = 1, r = 0;

struct Node {
    int l, r, tl, tr, cnt;
    long long sum;

    Node() : l(-1), r(-1), tl(0), tr(0), cnt(0), sum(0) {}
};

vector<Node> node;
vector<int> root;
int cnt = 1;

void pushup(int idx) {
    int idl = node[idx].tl, idr = node[idx].tr;
    node[idx].sum = node[idl].sum + node[idr].sum;
    node[idx].cnt = node[idl].cnt + node[idr].cnt;
    return;
}

void build(int l, int r, int idx = 1) {
    node[idx].l = l, node[idx].r = r;
    return;
}

int update(int tl, int tr, int p, int idx) {
    int cur = ++cnt;
    node[cur].l = tl, node[cur].r = tr;
    if (tl == tr && tl == p) {
        node[cur].cnt = node[idx].cnt + 1;
        node[cur].sum = node[idx].sum + sum[p - 1];
        return cur;
    }
    if (p < tl || p > tr)
        return cur;
    int mid = (tl + tr) >> 1;
    if (p <= mid) {
        node[cur].tr = node[idx].tr;
        node[cur].tl = update(tl, mid, p, node[idx].tl);
    } else if (p > mid) {
        node[cur].tl = node[idx].tl;
        node[cur].tr = update(mid + 1, tr, p, node[idx].tr);
    }
    pushup(cur);
    return cur;
}

int tans = 0, p = 0, tk = 0;

int query(int l, int r, int idx) {
    if (idx == 0) {
        p = r;
        return -1;
    }
    if (node[idx].cnt + tans < tk) {
        tans += node[idx].cnt;
        p = r;
        return -1;
    }
    if (l == r)
        return 0;
    int mid = (l + r) >> 1;
    int res = 0;
    if (l <= mid)
        res = query(l, mid, node[idx].tl);
    if (res == -1 && r > mid) {
        query(mid + 1, r, node[idx].tr);
    }
    return 0;
}

long long getsum(int l, int r, int idx) {
    if (idx == 0)
        return 0;
    int tl = node[idx].l, tr = node[idx].r;
    if (l <= tl && tr <= r) {
        return node[idx].sum;
    }
    if (l > tr || r < tl || l > r)
        return 0;
    long long ans = 0;
    int mid = (tl + tr) >> 1;
    if (l <= mid) {
        ans += getsum(l, r, node[idx].tl);
    }
    if (r > mid) {
        ans += getsum(l, r, node[idx].tr);
    }
    return ans;
}

vector<long long> ans;
int tot = 0;

void getans(int l, int r, int lk, int rk) {
    // ++tot;
    // if(tot >= 1000){
    //     return;
    // }
    if (lk + 1 >= rk)
        return;
    int idx = -1;
    int k = (lk + rk) >> 1;
    tk = k - 1;
    for (int i = l; i <= r; ++i) {
        if (que[i] < k)
            continue;
        int tot = 0;
        tans = 0, p = 0;
        query(1, sum.size(), root[que[i] - 1]);
        // cout << tl << " " << "\n";
        // cout << getsum(1, tl, root[que[i] - 1]) << " " << (k - 1 - query(1, tl, root[que[i] - 1])) * tr << "\n";
        long long tsum = getsum(1, p, root[que[i] - 1]) + 1LL * (tk - tans) * sum[p] + ab[que[i]].first + ab[que[i]].second;
        if (idx == -1) {
            ans[k] = tsum;
            idx = i;
        } else if (ans[k] > tsum) {
            ans[k] = tsum;
            idx = i;
        }
    }
    // cout << idx << "\n";
    getans(l, idx, lk, k);
    getans(idx, r, k, rk);
    return;
}

void solve() {
    cin >> n;

    sum.resize(n), ab.resize(n + 1);
    for (int i = 1; i <= n; ++i) {
        long long ta = 0, tb = 0;
        cin >> ta >> tb;
        sum[i - 1] = ta;
        ab[i].first = ta, ab[i].second = tb;
    }

    sort(sum.begin(), sum.end());
    sum.erase(unique(sum.begin(), sum.end()), sum.end());
    for (int i = 0; i < sum.size(); ++i) {
        mp[sum[i]] = i + 1;
    }

    que.resize(n + 1);

    sort(ab.begin(), ab.end(), [&](pair<long long, long long> a, pair<long long, long long> b) { return a.second < b.second; });

    for (int i = 1; i <= n; ++i) {
        while (l <= r && ab[i].first + ab[i].second <= ab[que[r]].first + ab[que[r]].second) --r;
        que[++r] = i;
    }

    node.resize(sum.size() << 6);
    build(1, sum.size());

    root.resize(n + 1);
    root[0] = 1;

    for (int i = 1; i <= n; ++i) {
        root[i] = update(1, sum.size(), mp[ab[i].first], root[i - 1]);
    }

    ans.resize(n + 1);

    getans(l, r, 0, n + 1);

    for (int i = 1; i <= n; ++i) cout << ans[i] << "\n";

    return;
}

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

    int t = 1;
    // cin >> t;
    while (t--) solve();

    return 0;
}