#pragma GCC optimize("O3,unroll-loops")
#include <cstdio>
#include <cstdint>

using namespace std;

const int N = 1500032;
const int SZ_L1 = N / 32;        
const int SZ_L2 = (SZ_L1 + 31) / 32; 
const int SZ_L3 = (SZ_L2 + 31) / 32; 

uint8_t V[N];
uint8_t L1[SZ_L1];
uint8_t L2[SZ_L2];
uint8_t L3[SZ_L3];

inline int max_int(int a, int b) { return a > b ? a : b; }

inline void update_V(int k, uint8_t v) {
    int idx = k % N;
    V[idx] = v;
    
    int i1 = idx / 32;
    if (v >= L1[i1]) {
        L1[i1] = v;
    } else {
        uint8_t m = 0;
        int b_start = i1 * 32;
        for(int j=0; j<32; ++j) {
            if (V[b_start + j] > m) m = V[b_start + j];
        }
        L1[i1] = m;
    }
    
    int i2 = i1 / 32;
    if (L1[i1] >= L2[i2]) {
        L2[i2] = L1[i1];
    } else {
        uint8_t m = 0;
        int b_start = i2 * 32;
        int b_end = b_start + 32;
        if (b_end > SZ_L1) b_end = SZ_L1;
        for(int j=b_start; j<b_end; ++j) {
            if (L1[j] > m) m = L1[j];
        }
        L2[i2] = m;
    }
    
    int i3 = i2 / 32;
    if (L2[i2] >= L3[i3]) {
        L3[i3] = L2[i2];
    } else {
        uint8_t m = 0;
        int b_start = i3 * 32;
        int b_end = b_start + 32;
        if (b_end > SZ_L2) b_end = SZ_L2;
        for(int j=b_start; j<b_end; ++j) {
            if (L2[j] > m) m = L2[j];
        }
        L3[i3] = m;
    }
}

inline uint8_t query_V_interval(int l, int r) {
    uint8_t res = 0;
    while (l <= r && (l & 31) != 0) {
        if (V[l] > res) res = V[l];
        l++;
    }
    if (res == 255) return 255;
    while (l <= r && (r & 31) != 31) {
        if (V[r] > res) res = V[r];
        r--;
    }
    if (res == 255) return 255;
    if (l > r) return res;

    l /= 32;
    r /= 32;
    while (l <= r && (l & 31) != 0) {
        if (L1[l] > res) res = L1[l];
        l++;
    }
    if (res == 255) return 255;
    while (l <= r && (r & 31) != 31) {
        if (L1[r] > res) res = L1[r];
        r--;
    }
    if (res == 255) return 255;
    if (l > r) return res;

    l /= 32;
    r /= 32;
    while (l <= r && (l & 31) != 0) {
        if (L2[l] > res) res = L2[l];
        l++;
    }
    if (res == 255) return 255;
    while (l <= r && (r & 31) != 31) {
        if (L2[r] > res) res = L2[r];
        r--;
    }
    if (res == 255) return 255;
    if (l > r) return res;

    l /= 32;
    r /= 32;
    while (l <= r) {
        if (L3[l] > res) res = L3[l];
        l++;
    }
    return res;
}

inline uint8_t query_V(int L, int R) {
    if (L > R) return 0;
    int l_idx = L % N;
    int r_idx = R % N;
    if (l_idx <= r_idx) {
        return query_V_interval(l_idx, r_idx);
    } else {
        uint8_t res1 = query_V_interval(l_idx, N - 1);
        uint8_t res2 = query_V_interval(0, r_idx);
        return res1 > res2 ? res1 : res2;
    }
}

struct StackElement {
    int idx;
    uint8_t val;
};
StackElement stk[300];
int stk_sz = 0;

inline void push_first_half(int idx, uint8_t val) {
    while (stk_sz > 0 && stk[stk_sz - 1].val <= val) {
        stk_sz--;
    }
    stk[stk_sz++] = {idx, val};
}

inline uint8_t query_first_half(int l) {
    if (stk_sz == 0) return 0;
    int low = 0, high = stk_sz - 1;
    uint8_t res = 0;
    while (low <= high) {
        int mid = (low + high) >> 1;
        if (stk[mid].idx >= l) {
            res = stk[mid].val;
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    return res;
}

const int IN_BUF = 1 << 16;
char in_buf[IN_BUF];
int in_pos = 0, in_len = 0;

inline char get_char() {
    if (in_pos == in_len) {
        in_len = fread(in_buf, 1, IN_BUF, stdin);
        in_pos = 0;
        if (in_len == 0) return -1;
    }
    return in_buf[in_pos++];
}

inline int read_int() {
    char c = get_char();
    if (c == -1) return -1;
    while (c <= 32) {
        c = get_char();
        if (c == -1) return -1;
    }
    int res = 0;
    while (c > 32) {
        res = res * 10 + (c - '0');
        c = get_char();
    }
    return res;
}

const int OUT_BUF = 1 << 16;
char out_buf[OUT_BUF];
int out_pos = 0;

inline void write_char(char c) {
    if (out_pos == OUT_BUF) {
        fwrite(out_buf, 1, OUT_BUF, stdout);
        out_pos = 0;
    }
    out_buf[out_pos++] = c;
}

inline void write_int(int x) {
    if (x == 0) {
        write_char('0');
        write_char('\n');
        return;
    }
    char buf[4];
    int len = 0;
    while (x) {
        buf[len++] = x % 10 + '0';
        x /= 10;
    }
    while (len--) {
        write_char(buf[len]);
    }
    write_char('\n');
}

inline void flush_out() {
    if (out_pos > 0) {
        fwrite(out_buf, 1, out_pos, stdout);
        out_pos = 0;
    }
}

int main() {
    int Q = read_int();
    if (Q == -1) return 0;
    
    int M_curr = 0;
    
    for (int i = 1; i <= Q; ++i) {
        int v_i = read_int();
        int l_i = read_int();
        int r_i = read_int();
        
        update_V(i, (uint8_t)v_i);
        
        int M_new = (i + 1) / 2;
        while (M_curr < M_new) {
            M_curr++;
            push_first_half(M_curr, V[M_curr % N]);
        }
        
        uint8_t ans = 0;
        if (l_i <= M_new) {
            uint8_t val = query_first_half(l_i);
            if (val > ans) ans = val;
        }
        if (r_i > M_new) {
            int L_second = max_int(l_i, M_new + 1);
            int R_second = r_i;
            if (L_second <= R_second) {
                uint8_t val = query_V(L_second, R_second);
                if (val > ans) ans = val;
            }
        }
        
        write_int(ans);
    }
    
    flush_out();
    return 0;
}