// VSCF.cpp : Defines the entry point for the console application.
//
#include <random>
#include <climits>
#include <queue>
#include <bitset>
#include <cassert>
#include <functional>
#include <cmath>
#include <list>
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <string>
#include <vector>
#include <set>
#include <deque>
#include <map>
#include <iomanip>
#include <sstream>
using namespace std;

#define int long long

typedef long long LL;
typedef pair<int, int> PII;
#define MP make_pair
#define FOR(v,p,k) for(int v=p;v<=k;++v)
#define FORD(v,p,k) for(int v=p;v>=k;--v)
#define REP(i,n) for(int i=0;i<(n);++i)
#define VAR(v,i)  decltype(i) v=(i)
#define FOREACH(i,c) for(VAR(i,(c).begin());i!=(c).end();++i)
#define PB push_back
#define ST first
#define ND second
#define SIZE(x) (int)x.size()
#define ALL(c) c.begin(),c.end()
#define MAXN 1000010
typedef long double LD;
typedef vector<int> VI;

vector<vector<int>> numbers(1e6 + 1);
PII EMPTY = MP(-1LL, -1LL);
struct przedzial {
	int l, r;
	int spychWynik;
	int spychMnoznik;
	int mnoznik;
	int dodane;
	PII szacowanieMaks;
	przedzial() {
		l = r = spychMnoznik = spychWynik = mnoznik = dodane = 0;
		szacowanieMaks = { -1, -1 };
	}
};
int M = 1e6;
struct drzewo {
	vector<przedzial> d;
	drzewo() {
		d.resize(4 * M);
		init(1, 0, M);
	}
	void init(int idx, int l, int r) {
		d[idx].l = l;
		d[idx].r = r;
		if (l == r) {
			if (!numbers[l].empty()) {
				d[idx].szacowanieMaks = {numbers[l].back(), numbers[l].back()};
			}
		} else {
			int m = (l + r) / 2;
			init(idx * 2, l, m);
			init(idx * 2 + 1, m + 1, r);
			int t = max(d[idx * 2].szacowanieMaks.first, d[idx * 2 + 1].szacowanieMaks.first);
			d[idx].szacowanieMaks = {
				t, t
			};
		}
	}
	void spychaj(int idx) {
		if (d[idx].szacowanieMaks == EMPTY) {
			return;
		}
		int l, r;
		l = d[idx].l;
		r = d[idx].r;
		if (l == r) {
			if (numbers[l].empty()) {
				d[idx].szacowanieMaks = EMPTY;
				return;
			} else {
				d[idx].mnoznik += d[idx].spychMnoznik;
				d[idx].dodane += d[idx].spychWynik;
				int t = d[idx].dodane + d[idx].mnoznik * l + numbers[l].back();
				d[idx].szacowanieMaks = { t,t };
			}
		} else {
			REP(i, 2) {
				d[2 * idx + i].spychWynik += d[idx].spychWynik;
				d[2 * idx + i].spychMnoznik += d[idx].spychMnoznik;
			}
			d[idx].szacowanieMaks = {
				d[idx].szacowanieMaks.first + l * d[idx].spychMnoznik + d[idx].spychWynik,
				d[idx].szacowanieMaks.second + r * d[idx].spychMnoznik + d[idx].spychWynik,
			};
		}
		d[idx].spychMnoznik = 0;
		d[idx].spychWynik = 0;
	}

	void update(int idx) {
		d[idx].szacowanieMaks = {
			max(d[2 * idx].szacowanieMaks.first, d[2 * idx + 1].szacowanieMaks.first),
			max(d[2 * idx].szacowanieMaks.second, d[2 * idx + 1].szacowanieMaks.second),
		};
	}

	void addHlp(int idx, int nl, int nr, int v) {
		int l, r;
		l = d[idx].l;
		r = d[idx].r;
		nl = max(l, nl);
		nr = min(r, nr);
		if (nl > nr) {
			return;
		}
		if (l == nl && r == nr) {
			d[idx].spychWynik += v;
			spychaj(idx);
		} else {
			spychaj(idx);
			addHlp(idx * 2, nl, nr, v);
			addHlp(idx * 2 + 1, nl, nr, v);
			update(idx);
		}
	}

	void add(int nl, int nr, int v) {
		addHlp(1, nl, nr, v);
	}

	void multHlp(int idx, int nl, int nr, int v) {
		int l, r;
		l = d[idx].l;
		r = d[idx].r;
		nl = max(l, nl);
		nr = min(r, nr);
		if (nl > nr) {
			return;
		}
		if (l == nl && r == nr) {
			d[idx].spychMnoznik += v;
			spychaj(idx);
		} else {
			spychaj(idx);
			multHlp(idx * 2, nl, nr, v);
			multHlp(idx * 2 + 1, nl, nr, v);
			update(idx);
		}
	}

	void mult(int nl, int nr, int v) {
		multHlp(1, nl, nr, v);
	}

	int wezNajlepszego() {
		vector<int> potentialWinners = { 1 };
		int lbres = 0;
		int res = 0;
		int idxRes;
		while (!potentialWinners.empty()) {
			vector<int> nextWinners;
			for (int a : potentialWinners) {
				spychaj(a);
				int lres, hres;
				lres = d[a].szacowanieMaks.first;
				hres = d[a].szacowanieMaks.second;
				if (hres < lbres) {
					continue;
				}
				lbres = max(lres, lbres);
				if (d[a].l == d[a].r) {
					if (hres > res) {
						res = hres;
						idxRes = a;
					}
				} else {
					nextWinners.push_back(2 * a);
					nextWinners.push_back(2 * a + 1);
				}
				
			}
			swap(nextWinners, potentialWinners);
		}
		int win = d[idxRes].l;
		numbers[win].pop_back();
		spychaj(idxRes);
		int t = idxRes / 2;
		while (t) {
			update(t);
			t /= 2;
		}
		add(0, win, win);
		mult(win + 1, M, 1);
		return res;
	}
};
#undef int
int main() {
#define int long long
	ios_base::sync_with_stdio(0);
	int n;
	n = 1e6;
	cin >> n;
	REP(i, n) {
		int t1, t2;
		cin >> t1 >> t2;
		numbers[t1].push_back(t2);
	}
	REP(i, 1e6) {
		sort(ALL(numbers[i]));
	}
	drzewo d;
	int res = 0;
	REP(i, n) {
		res += d.wezNajlepszego();
		cout << res << "\n";
	}
	return 0;
}