#include<iostream>
#include<cstring>
#include<vector>
#include<array>
#include<algorithm>
using namespace std;
using LL = long long;
const int maxn = 2e6 + 5;
// LL tr[maxn * 4];

// void modify(int u, int l, int r, int x, int v){
//     if (l == r){
//         tr[u] += v;
//         return;
//     }
//     int mid = (l + r) / 2;
//     if (x <= mid) modify(2 * u, l, mid, x, v);
//     else modify(2 * u + 1, mid + 1, r, x, v);
//     tr[u] = tr[2 * u] + tr[2 * u + 1];
// }

// int find_first(int u, int l, int r, LL target){
//     if (tr[u] < target) return r + 1;
//     if (l == r) return r;
//     int mid = (l + r) / 2;
//     if (tr[2 * u] >= target) return find_first(2 * u, l, mid, target);
//     return find_first(2 * u + 1, mid + 1, r, target - tr[2 * u]);
// }

struct BIT{
    LL tr[maxn];

    int lowbit(int x){
        return x & -x;
    }

    void modify(int x, LL v){
        while(x < maxn){
            tr[x] += v;
            x += lowbit(x);
        }
    }

    LL query(int x){
        LL ans = 0;
        while(x){
            ans += tr[x];
            x -= lowbit(x);
        }
        return ans;
    }

    LL query(int l, int r){
        return query(r) - query(l - 1);
    }

    int find_first(LL sum){
        int ans = 0; LL val = 0;
        for(int i = 21; i >= 0; i--){
            if ((ans | (1 << i)) < maxn && val + tr[ans | (1 << i)] < sum){
                ans |= 1 << i;
                val += tr[ans];
            }
        }
        return ans + 1;
    }
}bit[3];

int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);

    int n;
    cin >> n;
    vector<int> nums;
    vector<array<int, 4> > ops(n);
    for(int i = 0; i < n; i++){
        int op;
        cin >> op;
        if (op == 1){
            int t, x, y;
            cin >> t >> x >> y;
            ops[i] = {1, t, x, y};
            nums.push_back(x);
        }
        else{
            int x;
            cin >> x;
            x--;
            ops[i] = {2, x};
        }
    }
    sort(nums.begin(), nums.end());
    nums.erase(unique(nums.begin(), nums.end()), nums.end());

    auto get = [&](int x){
        return lower_bound(nums.begin(), nums.end(), x) - nums.begin() + 1;
    };
    
    const int m = nums.size();

    for(auto &[op, t, x, y] : ops){
        if (op == 1){
            x = get(x);
            bit[t].modify(x, y);
            bit[2].modify(x, y);
        }
        else{
            auto [_, tt, xx, yy] = ops[t];
            bit[tt].modify(xx, -yy);
            bit[2].modify(xx, -yy);
        }
        int pos = bit[2].find_first(bit[1].query(m));
        LL mx = 0;
        for(int i = -2; i <= 2; i++){
            int t = pos + i;
            if (t >= 1 and t <= m){
                LL cost = min(bit[0].query(t), bit[1].query(m) - bit[1].query(t - 1));
                mx = max(mx, cost);
            }
        }
        if (mx == 0) cout << "Peace" << '\n';
        else{
            LL remain = bit[1].query(m) - mx + 1;
            int pos = bit[1].find_first(remain);
            if (bit[1].query(pos, m) < mx) pos--;
            if (bit[1].query(pos + 1, m) >= mx) pos++;
            cout << nums[pos - 1] << ' ' << 2 * mx << '\n';
        } 
        
    }

}