#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;

enum LOC{
	to_left,
	to_right,
};

struct Info{
	bool operator<(const struct Info &arg) const{
		return per_time < arg.per_time;
	};
	int per_time,sum_time,rest_count;
	double position,pre_pos;
	LOC loc;
	bool erased;
};

int N;
LOC most_slow_loc;
int most_slow_id,most_slow_sum_time,most_slow_per_time;

void func(){

	vector<Info> V;

	for(int i = 0; i < N; i++){
		Info info;
		scanf("%d %d",&info.per_time,&info.rest_count);
		info.sum_time = 0;
		info.loc = to_left;
		info.position = 0;
		info.erased = false;
		V.push_back(info);
	}

	sort(V.begin(),V.end());

	int num = N;
	int ans = 0,index;
	double tmp;

	for(int time = 1; time <= 160000; time++){

		if(num == 1){

			for(int i = 0; i < V.size();i++){
				if(V[i].erased == false){
					index = i;
					break;
				}
			}

			V[index].position = (double)(time-V[index].sum_time)/(double)V[index].per_time;

			if(V[index].position >= 1.0){
				if(V[index].loc == to_left){
					ans = time + V[index].per_time + 2*(V[index].rest_count-1)*V[index].per_time;
					num--;
				}else{
					V[index].rest_count -= 1;
					if(V[index].rest_count == 0){
						ans = time;
						num--;
					}else{
						ans = time + 2*V[index].rest_count*V[index].per_time;
						num--;
					}
				}
			}

		}else{

			for(int i = V.size()-1; i >= 0; i--){
				if(V[i].erased)continue;
				V[i].pre_pos = V[i].position;
				V[i].position = (double)(time-V[i].sum_time)/(double)V[i].per_time;
			}
			for(int i = V.size()-2; i >= 0;i--){
				if(V[i].erased)continue;
				index = -1;
				for(int k = i+1; k < V.size();k++){
					if(V[k].erased == true || k == i)continue;

					if(V[i].loc == V[k].loc && V[i].pre_pos < V[k].pre_pos){
						if(index == -1){
							tmp = V[k].pre_pos;
							index = k;
						}else{
							if(tmp > V[k].pre_pos){
								tmp = V[k].pre_pos;
								index = k;
							}
						}
					}
				}
				if(index == -1){
					//Do nothing
				}else{
					if(V[i].position >= V[index].position){
						if(V[index].position >= 1.0){

						}else{
							V[i].position = V[index].position-EPS;
						}
					}
				}
			}

			for(int i = 0; i < V.size();i++){
				if(V[i].erased)continue;

				if(V[i].position >= 1.0){
					V[i].sum_time = time;
					V[i].position = 0.0;
					if(V[i].loc == to_left){
						V[i].loc = to_right;
					}else{
						V[i].rest_count -= 1;
						if(V[i].rest_count == 0){
							ans = time;
							V[i].erased = true;
							num--;
						}else{
							V[i].loc = to_left;
						}
					}
				}
			}
		}

		if(num == 0)break;
	}

	printf("%d\n",ans);
}

int main(){

	while(true){
		scanf("%d",&N);
		if(N == 0)break;

		func();
	}

	return 0;
}