#include <bits/stdc++.h>

using namespace std;

ifstream f("buline.in");
ofstream g("buline.out");

int n, v[200005], smax = INT_MIN, smin = INT_MAX, s, sum, st_max, dr_max, st, st_min, dr_min;
bool t;

int main(void)
{
    f >> n;
    
    for (int i = 1; i <= n; i++) {
        f >> v[i] >> t;
        
        if (!t) {
            v[i] *= (-1); // valori negative pentru bile negre
        }
        
        sum += v[i]; // calculez suma totala
    }
    
    // PENTRU SUMA MAXIMA
    s = v[1]; // initializez suma curenta
    st_max = dr_max = st = 1; // pozitia secventei maxime
    
    for (int i = 2; i <= n; i++) {
        if (s + v[i] >= v[i]) { // extind secventa curenta
            s += v[i];
        } else { // incep o noua secventa
            s = v[i];
            st = i;
        }
        
        if (s > smax) { // actualizez suma maxima
            smax = s;
            st_max = st;
            dr_max = i;
        }
    }
    
    // PENTRU SUMA MINIMA PENTRU CAZUL CIRCULAR
    // analog ca la suma maxima
    s = v[1]; // initializez suma curenta
    st_min = dr_min = st = 1; // pozitia secventei minime
    
    for (int i = 2; i <= n; i++) {
        if (s + v[i] <= v[i]) { // extind secventa curenta
            s += v[i];
        } else { // incep o noua secventa
            s = v[i];
            st = i;
        }
        
        if (s < smin) { // actualizez suma minima
            smin = s;
            st_min = st;
            dr_min = i;
        }
    }
    
    // comparam suma maxima obtinuta cu cea care trece circular
    if (smax > sum - smin)
        g << smax << " " << st_max << " " << dr_max - st_max + 1;
    else
        // *Calculăm corect poziția secvenței în cazul circular*
        // dr_min + 1 este prima poziție după secvența minimă
        // st_min - 1 este ultima poziție înainte de secvența minimă
        // n - dr_min reprezintă lungimea bucății rămase după eliminarea secvenței minime
        g << sum - smin << " " << dr_min + 1 << " " << st_min - 1 + n - dr_min; 
    
    return 0;
}



/*5
1 0 // valoarea 1, dar bila e neagra, deci devine -1
2 1 // 2, ramane 2
4 0 // -4
3 1 // 3
5 1 // 5

v = [-1, 2, -4, 3, 5]
sum = 5

calculez suma maxima (kadane)
i   v[i]   s(curent)    st (start)    smax(maxim gasit)   st_max   dr_max
1    -1        -1           1                -1              1       1               
2     2         2           2                 2              2       2                 
3    -4        -2           3                 2              2       2                           
4     3         3           4                 3              4       4                 
5     5         8           4                 8              4       5  

smax = 8, lungime 5 - 4 + 1 = 2

calculez suma minima (kadane invers)
i   v[i]   s(curent)    st (start)    smin(minim gasit)   st_min   dr_min
1    -1        -1           1                -1              1       1               
2     2         1           2                -1              1       1                 
3    -4        -4           3                -4              3       3                           
4     3        -1           4                -4              3       3                 
5     5         4           5                -4              3       3 

smin = -4, poz (3, 3)

suma maxima circulara: 5 - (-4) = 9

9 > 8


calculez pozitiile pentru cazul circular
st      = dr_min + 1              = 3 + 1 = 4
lungime = st_min - 1 + n - dr_min = 3 - 1 + 5 - 3 = 4

asadar, output ul este
9 4 4*/