#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <bitset>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath> // 変数名にy1が使えなくなるかも…。
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <string>

typedef __int128_t int128_t;
std::istream &operator>>(std::istream& input, int128_t& value) { // int128_tの入力。入力が64bitに収まる前提。
    long long tmp; input >> tmp; value = tmp;
    return input;
}
std::ostream &operator<<(std::ostream& output, const int128_t value) { // int128_tの出力。出力が64bitに収まる前提。
    output << (long long)value;
    return output;
}

// binary search result
struct BSR {
    bool found; // 条件を満たす範囲が見つかったか。falseの場合、begin,endは意味を持たない。
    int128_t begin; // [begin, end]で条件が成り立つ。
    int128_t end;

    BSR(bool found_in, int128_t begin_in, int128_t end_in) : found(found_in), begin(begin_in), end(end_in) {}
};

template<class Fn> BSR binary_search(int128_t L, int128_t R, Fn func) {
    const bool res_L = func(L);
    const bool res_R = func(R);
    if (res_L && res_R) {
        return BSR(true, L, R);
    } else if (!res_L && !res_R) {
        return BSR(false, 0, 0);
    } else {
        int128_t lb = L;
        int128_t ub = R;
        while (lb + 1 < ub) {
            int128_t mid = (lb + ub) / 2;
            if (res_L == func(mid)) {
                lb = mid;
            } else {
                ub = mid;
            }
        }
        if (res_L) {
            return BSR(true, L, lb);
        } else {
            return BSR(true, ub, R);
        }
    }
}

template<typename T>
std::map<T, int> coordinate_compress(const std::vector<T>& vec, const bool reverse = false) {
    // 座標圧縮。要素の小さい順に1-indexで値を割り振る。
    // reverse = trueの場合、大きい順に割り当てるが、mapでの保存順序は常に小さい順である。
    std::vector<T> tmp = vec;
    std::sort(tmp.begin(), tmp.end());
    tmp.erase(std::unique(tmp.begin(), tmp.end()), tmp.end());
    std::map<T, int> mp;
    for (int i = 0; i < tmp.size(); i++) {
        mp[tmp[i]] = reverse ? tmp.size() - i : i + 1;
    }
    return mp;
}

template<typename T>
std::vector<T> coordinate_expand(const std::map<T, int>& mp) {
    std::vector<T> ret; ret.resize(mp.size()+1);
    for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
        assert(itr->second < ret.size());
        ret[itr->second] = itr->first;
    }
    return ret;
}

class BIT {
    // Binary Indexed Tree : 数列要素1つへの加算、数列のある地点までの累積和を高速に計算
    public:
    std::vector<long long> data;
    BIT() {}
    BIT(const int size) {
        // 想定されるサイズの2倍の値を入れた方がいいかもしれない。数列は1から数えることを想定している。
        data.resize(size, 0);
    }
    long long sum(int i) const {
        long long s = 0;
        while (i > 0) {
            s += data[i];
            i = i & (i-1); // iの最後のビットを引く。
        }
        return s;
    }

    long long val(int i) const {
        if (i == 1) { return sum(i); }
        else {
            return sum(i) - sum(i-1);
        }
    }

    void add(int i, long long x) {
        while (i < data.size()) {
            data[i] += x;
            i += i - (i & (i-1)); // iの最後のビットを加算する。
        }
    }
};

const int MAX_Q = 200050;
int Q;
int128_t query[MAX_Q][3];

BIT bit_coord = BIT(MAX_Q);
BIT bit_value = BIT(MAX_Q);

int main(int argc, char **argv) {
    std::cin >> Q;

    for (int i = 1; i <= Q; i++) {
        std::cin >> query[i][0];
        if (query[i][0] == 1) {
            std::cin >> query[i][1] >> query[i][2];
        }
    }

    std::vector<int128_t> a_vec;
    for (int i = 1; i <= Q; i++) {
        if (query[i][0] == 1) {
            a_vec.push_back(query[i][1]);
        }
    }
    auto compress = coordinate_compress<int128_t>(a_vec);
    auto expand = coordinate_expand<int128_t>(compress);

    int128_t bsum = 0;
    for (int i = 1; i <= Q; i++) {
        if (query[i][0] == 1) {
            bit_coord.add(compress[query[i][1]], 1);
            bit_value.add(compress[query[i][1]], query[i][1]);
            bsum += query[i][2];
        } else {
            const int num = bit_coord.sum(compress.size());
            BSR bsr = binary_search(1, compress.size(),
                [&](const int i) { 
                    return bit_coord.sum(i) * 2 >= num;
                }
            );
            int128_t ret = 0;
            ret += bit_coord.sum(bsr.begin - 1) * expand[bsr.begin];
            ret -= bit_value.sum(bsr.begin - 1);
            ret += bit_value.sum(compress.size()) - bit_value.sum(bsr.begin);
            ret -= (bit_coord.sum(compress.size()) - bit_coord.sum(bsr.begin)) * expand[bsr.begin];
            std::cout << expand[bsr.begin] << " " << ret + bsum << std::endl;
        }
    }
    return 0;
}

Measured memory_bytes: 26068