#include <bits/stdc++.h>

#define lsb(x) (x & (-x))

using ull = unsigned long long;
using ll = long long;

using namespace std;

constexpr int MAXA = (int) 2e5;

struct SegTree {
    struct Node {
        int l = -1, r = -1;
        ll sum = 0;
        int count = 0;
    };

    SegTree() {
        makeNode();
    }

    inline int makeNode(int oldId) {
        if (oldId == -1) {
            return makeNode();
        }
        data.push_back(data[oldId]);
        return (int)data.size() - 1;
    }

    inline int makeNode() {
        data.emplace_back();
        return (int)data.size() - 1;
    }

    int update(int id, int l, int r, int pos, int val) {
        int newId = makeNode(id);

        if (l == r) {
            data[newId].sum += val;
            data[newId].count++;
        } else {
            int mid = (l + r) / 2;

            if (pos <= mid) {
                int idl = update(data[newId].l, l, mid, pos, val);
                data[newId].l = idl;
            } else {
                int idr = update(data[newId].r, mid + 1, r, pos, val);
                data[newId].r = idr;
            }

            data[newId].sum += val;
            data[newId].count++;
        }
 
        return newId;
    }

    ll query(int id, int k) {
        ll answer = query(id, 1, MAXA, k);
        if (k != 0) {
            return 1e18;
        }
        return answer;
    }

private:
    ll query(int id, int l, int r, int& k) {
        if (id == -1 || k <= 0) return 0LL;

        if (data[id].count <= k) {
            k -= data[id].count;
            return data[id].sum;
        } else {
            int mid = (l + r) / 2;
            ll answer = query(data[id].l, l, mid, k);
            answer += query(data[id].r, mid + 1, r, k);
            return answer;
        }
    }

public:
    vector<Node> data;
};

struct Dish {
    int a, b;
    bool operator<(const Dish& dish) const {
        if (b == dish.b)
            return a > dish.a;
        return b < dish.b;
    }
};



int main() {
#ifdef HOME
    ifstream cin("input.in");
    ofstream cout("output.out");
#endif
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    int n;
    cin >> n;

    vector<Dish> dishes(n);
    vector<int> nrm_a;
    for (auto& dish : dishes) {
        cin >> dish.a >> dish.b;
        nrm_a.push_back(dish.a);
    }
    sort(dishes.begin(), dishes.end());
    sort(nrm_a.begin(), nrm_a.end());
    nrm_a.resize(unique(nrm_a.begin(), nrm_a.end()) - nrm_a.begin());

    SegTree st;
    vector<int> roots(n + 1);

    vector<int> norm(n);
    vector<int> stk;
    map<pair<int, int>, int> cache;

    auto Get = [&](int p1, int p2) {
        if (cache.find({p1, p2}) != cache.end()) {
            return cache[{p1, p2}];
        }

        int nrm1 = norm[p1], nrm2 = norm[p2];
        int root1 = roots[nrm1], root2 = roots[nrm2];
        int k = 0;
        for (int step = 1 << 17; step; step >>= 1) {
            if (k + step <= st.data[root2].count) {
                ll s1 = st.query(root1, k + step) + dishes[p1].b;
                ll s2 = st.query(root2, k + step) + dishes[p2].b;
                if (s1 < s2) {
                    k += step;
                }
            }
        }
        return cache[{p1, p2}] = k;
    };  

    int i = 0;
    while (i < n) {
        static int nrm = 0;
        nrm++;
        roots[nrm] = roots[nrm - 1];

        int j = i;
        while (j < n && dishes[i].b == dishes[j].b) {
            int norm_a = lower_bound(nrm_a.begin(), nrm_a.end(), dishes[j].a) - nrm_a.begin() + 1;
            roots[nrm] = st.update(roots[nrm], 1, MAXA, norm_a, dishes[j].a);
            norm[j++] = nrm;
        }
        i = j;

        int pos = i - 1;
        while (stk.size() > 1 && Get(stk[stk.size() - 2], stk.back()) >= Get(stk.back(), pos)) {
            stk.pop_back();
        }
        stk.push_back(pos);
    }

    int k = 1;
    for (int i = 0; i < (int)stk.size(); i++) {
        int curr = (i == (int)stk.size() - 1 ? n : Get(stk[i], stk[i + 1]));
        while (k <= curr) {
            cout << st.query(roots[norm[stk[i]]], k) + dishes[stk[i]].b << "\n";
            k++;
        }
    }

    return 0;
}