#include <bits/stdc++.h>
using namespace std;

#define rep(i,n) for (int i=0;i<(n);i++)
#define rep2(i,a,b) for (int i=(a);i<(b);i++)
#define rrep(i,n) for (int i=(n)-1;i>=0;i--)
#define rrep2(i,a,b) for (int i=(a)-1;i>=b;i--)
#define chmin(a,b) (a)=min((a),(b));
#define chmax(a,b) (a)=max((a),(b));
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define printV(v) cerr<<(#v)<<":";for(auto(x):(v)){cerr<<" "<<(x);}cerr<<endl;
#define printVS(vs) cerr<<(#vs)<<":"<<endl;for(auto(s):(vs)){cerr<<(s)<< endl;}
#define printVV(vv) cerr<<(#vv)<<":"<<endl;for(auto(v):(vv)){for(auto(x):(v)){cerr<<" "<<(x);}cerr<<endl;}
#define printP(p) cerr<<(#p)<<(p).first<<" "<<(p).second<<endl;
#define printVP(vp) cerr<<(#vp)<<":"<<endl;for(auto(p):(vp)){cerr<<(p).first<<" "<<(p).second<<endl;}

inline void output(){ cerr << endl; }
template<typename First, typename... Rest>
inline void output(const First& first, const Rest&... rest) {
    cerr << first << " "; output(rest...);
}

using ll = long long;
using Pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
const int inf = 1e9;
const int mod = 1e9 + 7;
using Graph = vector<vector<int>>;

struct Range {
    int l, r; // [l, r]
    Range(){}
    Range(int _l, int _r) : l(_l), r(_r) {}
    bool operator<( const Range& o ) const {
        if (l != o.l) return l < o.l;
        return r < o.r;
    }
    void print() {
        cout << "l = " << l << ", r = " << r << endl;
    }
};

struct State {
    int t_in, t_pace, c_rem;
    State(){}
    State(int _t_in, int _t_pace, int _c_rem) : t_in(_t_in), t_pace(_t_pace), c_rem(_c_rem) {}
    bool operator<(const State& o) const {
        if (t_pace != o.t_pace) return t_pace < o.t_pace;
        if (c_rem != o.c_rem) return c_rem < o.c_rem;
        return t_in < o.t_in;
    }
    void print() {
        cerr << "(" << t_in << ", " << t_pace << ", " << c_rem << ")";
    }
};

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

    int n;
    while (cin >> n, n) {
        vector<deque<State>> deq(2);
        vector<State> initial_states;
        rep(i, n) {
            int t_pace, c_rem;
            cin >> t_pace >> c_rem;
            initial_states.emplace_back(0, t_pace, c_rem - 1);
        }
        sort(all(initial_states));
        for (auto state : initial_states) {
            deq[0].emplace_back(state);
        }

        auto printDeq = [&](){
            rep(k, 2) {
                cerr << k << ":";
                rep(i, deq[k].size()) {
                    cerr << " ";
                    deq[k][i].print();
                }
                cerr << endl;
            }
        };

        int t_max = 0;
        while (!(deq[0].empty() && deq[1].empty())) {
            int t_now_0 = (deq[0].empty() ? inf : deq[0].front().t_in + deq[0].front().t_pace);
            int t_now_1 = (deq[1].empty() ? inf : deq[1].front().t_in + deq[1].front().t_pace);
            int t_now = min(t_now_0, t_now_1);
            if (t_now_0 < t_now_1) {
                int k = 0;
                vector<State> states;
                // int t_now = deq[k].front().t_in + deq[k].front().t_pace;
                while (!deq[k].empty() && t_now >= deq[k].front().t_in + deq[k].front().t_pace) {
                    if (k && deq[k].front().c_rem == 0) {
                        t_max = t_now;
                    }
                    else {
                        states.emplace_back(deq[k].front());
                    }
                    deq[k].pop_front();
                }

                sort(all(states));

                for (auto state : states) {
                    deq[k^1].emplace_back(t_now, state.t_pace, state.c_rem - k);
                }
            }
            else if (t_now_0 > t_now_1) {
                int k = 1;
                vector<State> states;
                // int t_now = deq[k].front().t_in + deq[k].front().t_pace;
                while (!deq[k].empty() && t_now >= deq[k].front().t_in + deq[k].front().t_pace) {
                    if (k && deq[k].front().c_rem == 0) {
                        t_max = t_now;
                    }
                    else {
                        states.emplace_back(deq[k].front());
                    }
                    deq[k].pop_front();
                }

                sort(all(states));

                for (auto state : states) {
                    deq[k^1].emplace_back(t_now, state.t_pace, state.c_rem - k);
                }
            }
            else { // t_now_0 == t_now_1
                vector<vector<State>> states(2);
                rep(k, 2) {
                    // int t_now = deq[k].front().t_in + deq[k].front().t_pace;
                    while (!deq[k].empty() && t_now >= deq[k].front().t_in + deq[k].front().t_pace) {
                        if (k && deq[k].front().c_rem == 0) {
                            t_max = t_now;
                        }
                        else {
                            states[k].emplace_back(deq[k].front());
                        }
                        deq[k].pop_front();
                    }
                }

                rep(k, 2) {
                    sort(all(states[k]));
                    for (auto state : states[k]) {
                        deq[k^1].emplace_back(t_now, state.t_pace, state.c_rem - k);
                    }
                }
            }
        }

        cout << t_max << endl;
    }
}