Problem: Despite urging requests of the townspeople, the municipal office cannot afford to improve many of the apparently deficient city amenities under this recession. The city swimming pool is one of the typical examples. It has only two swimming lanes. The Municipal Fitness Agency, under this circumstances, settled usage rules so that the limited facilities can be utilized fully.

Two lanes are to be used for one-way swimming of different directions. Swimmers are requested to start swimming in one of the lanes, from its one end to the other, and then change the lane to swim his/her way back. When he or she reaches the original starting end, he/she should return to his/her initial lane and starts swimming again.

Each swimmer has his/her own natural constant pace. Swimmers, however, are not permitted to pass other swimmers except at the ends of the pool; as the lanes are not wide enough, that might cause accidents. If a swimmer is blocked by a slower swimmer, he/she has to follow the slower swimmer at the slower pace until the end of the lane is reached. Note that the blocking swimmer’s natural pace may be faster than the blocked swimmer; the blocking swimmer might also be blocked by another swimmer ahead, whose natural pace is slower than the blocked swimmer. Blocking would have taken place whether or not a faster swimmer was between them.

Swimmers can change their order if they reach the end of the lane simultaneously. They change their order so that ones with faster natural pace swim in front. When a group of two or more swimmers formed by a congestion reaches the end of the lane, they are considered to reach there simultaneously, and thus change their order there.

The number of swimmers, their natural paces in times to swim from one end to the other, and the numbers of laps they plan to swim are given. Note that here one "lap" means swimming from one end to the other and then swimming back to the original end. Your task is to calculate the time required for all the swimmers to finish their plans. All the swimmers start from the same end of the pool at the same time, the faster swimmers in front.

In solving this problem, you can ignore the sizes of swimmers' bodies, and also ignore the time required to change the lanes and the order in a group of swimmers at an end of the lanes.



Input

The input is a sequence of datasets. Each dataset is formatted as follows.

n
t1 c1
...
tn cn


n is an integer (1 ≤ n ≤ 50) that represents the number of swimmers. ti and ci are integers (1 ≤ ti ≤ 300, 1 ≤ ci ≤ 250) that represent the natural pace in times to swim from one end to the other and the number of planned laps for the i-th swimmer, respectively. ti and ci are separated by a space.

The end of the input is indicated by a line containing one zero.

Output

For each dataset, output the time required for all the swimmers to finish their plans in a line. No extra characters should occur in the output.

Example

Input

2
10 30
15 20
2
10 240
15 160
3
2 6
7 2
8 2
4
2 4
7 2
8 2
18 1
0


Output

600
4800
36
40

Solution (in CPP):

Solution:
#include <iostream>
#include <vector>
#include <cmath>
#include <string>
#include <climits>
#include <iomanip>
#include <algorithm>
#include <queue>
#include <map>
#include <tuple>
#include <iostream>
#include <deque>
#include <array>
#include <set>
#include <functional>
#include <memory>
#include <stack>
#include <numeric>
#include <climits>
#include <cfloat>
struct Record {
	int id, reach_time, speed;
	Record turn(const int time) const { return { id, time + speed, speed }; }
};
int main() {
	while (true) {
		int n; std::cin >> n; if (n == 0) return 0;
		std::vector<int> time(n); std::vector<int> target(n);
		for (auto i = 0; i < n; ++i) std::cin >> time[i] >> target[i];
		std::queue<Record> forward, backward;
		auto compare_by_speed = [](const Record& a, const Record& b) {return a.speed > b.speed; };
		std::priority_queue<Record, std::vector<Record>, decltype(compare_by_speed)> queue(compare_by_speed);
		for (auto i = 0; i < n; ++i) {
			queue.push(Record{ i, time[i], time[i] });
		}
		for (auto i = 0; i < n; ++i) {
			forward.push(queue.top()); queue.pop();
		}
		auto last_time = 0; auto end_count = 0;
		while (end_count != n) {
			while (!forward.empty() && (backward.empty() || backward.front().reach_time >= forward.front().reach_time)) {
				last_time = forward.front().reach_time;
				while (!forward.empty() && forward.front().reach_time <= last_time) {
					queue.push(forward.front()); forward.pop();
				}
				while (!queue.empty()) {
					backward.push(queue.top().turn(last_time)); queue.pop();
				}
			}
			while (!backward.empty() && (forward.empty() || forward.front().reach_time >= backward.front().reach_time)) {
				last_time = backward.front().reach_time;
				while (!backward.empty() && backward.front().reach_time <= last_time) {
					--target[backward.front().id];
					if (target[backward.front().id] != 0) {
						queue.push(backward.front());
					}
					else {
						++end_count;
					}
					backward.pop();
				}
				while (!queue.empty()) {
					forward.push(queue.top().turn(last_time)); queue.pop();
				}
			}
		}
		std::cout << last_time << std::endl;
	}
}