#include <algorithm>

template <typename T = int>
class AvlTree {
public:
    struct node {
        T key;
        int size, height;
        node* child[2];
        node(const T &key) : key(key), size(1), height(1) {
            child[0] = child[1] = 0;
        }
        node(node&&) = default;
        node(const node&) = default;
        node& operator = (const node&) = default;
        node& operator = (node&&) = default;
    };
private:
    // Variable
    node* root;
    
    // Functions
    int node_size_or(node* n) const {
        return n ? n->size : 0;
    }
    int node_height_or(node* n) const {
        return n ? n->height : 0;
    }

    node* find_impl(node *t, const T &key) {
        if(t == nullptr)
            return nullptr;
        if(key == t->key)
            return t;
        else if(key < t->key)
            return find_impl(t->child[0], key);
        else
            return find_impl(t->child[1], key);
    }
    node* insert_impl(node *t, node *x) {
        if (t == nullptr)
            return x;

        if(x->key <= t->key)
            t->child[0] = insert_impl(t->child[0], x);
        else
            t->child[1] = insert_impl(t->child[1], x);
        t->size += 1;

        return balance(t);
    }

    node* erase_impl(node *t, const T &x) {
        if (t == nullptr) return nullptr;
        if (x == t->key) {
            return move_down(t->child[0], t->child[1]);
        } else {
            if(x < t->key)
                t->child[0] = erase_impl(t->child[0], x);
            else
                t->child[1] = erase_impl(t->child[1], x);
            
            t->size -= 1;
            
            return balance(t);
        }
    }

    node* move_down(node *t, node *rhs) {
        if (t == nullptr) return rhs;
        t->child[1] = move_down(t->child[1], rhs);
        return balance(t);
    }

    node* rotate(node *t, int l, int r) {
        node *s = t->child[r];
        t->child[r] = s->child[l];
        s->child[l] = balance(t);
        if(t)
            t->size = node_size_or(t->child[0]) + node_size_or(t->child[1]) + 1;
        
        if(s)
            s->size = node_size_or(s->child[0]) + node_size_or(s->child[1]) + 1;

        return balance(s);
    }

    node* balance(node *t) {
        for (int i = 0; i < 2; ++i) {
            if (node_height_or(t->child[!i]) - node_height_or(t->child[i]) < -1) {
                if (node_height_or(t->child[i]->child[!i]) - node_height_or(t->child[i]->child[i]) > 0)
                    t->child[i] = rotate(t->child[i], i, !i);
                
                return rotate(t, !i, i);
            }
        }

        if(t)
            t->height = std::max(node_height_or(t->child[0]), node_height_or(t->child[1])) + 1;
        if(t)
            t->size = node_size_or(t->child[0]) + node_size_or(t->child[1]) + 1;

        return t;
    }

    node* rank_impl(node *t, int k) const {
        if (!t) return nullptr;
        int m = node_size_or(t->child[0]);
        
        if (k < m)
            return rank_impl(t->child[0], k);
        else if (k == m)
            return t;
        else
            return rank_impl(t->child[1], k - m - 1);
    }

public:
    AvlTree() {
        root = nullptr;
    }
    AvlTree(const AvlTree&) = delete;
    AvlTree(AvlTree&&) = default;
    AvlTree& operator = (const AvlTree&) = delete;
    AvlTree& operator = (AvlTree&&) = default;

    ~AvlTree() {
        delete root;
    }

    node* find(const T &key) {
        return find_impl(root, key);
    }
    void insert(const T &key) {
        root = insert_impl(root, new node(key));
    }
    void erase(const T &key) {
        root = erase_impl(root, key);
    }
    node* rank(int k) const {
        return rank_impl(root, k);
    }

};

#include <iostream>
#include <utility>
#include <vector>
int n, q;

int main() {
    std::cin >> n >> q;

    AvlTree<std::pair<long long, int>> tree;
    std::vector<long long> scores(n);

    for(int i = 0; i < n; ++i) {
        tree.insert(std::make_pair(0, i));
    }

    long long a, b, c;
    for(int i = 0; i < q; ++i) {
        std::cin >> a >> b;
        --b;

        if(a == 0) {
            std::cin >> c;

            auto p = tree.find(std::make_pair(scores[b], b));
            tree.erase(p->key);
            
            scores[b] -= c;

            tree.insert(std::make_pair(scores[b], b));
        }else {
            auto p = tree.rank(b);
            
            std::cout << p->key.second + 1 << " " << -p->key.first << std::endl;
        }
    }
}

/*
In:
3 11 
0 2 5
0 1 5
0 3 4
1 1
1 2
1 3
0 3 2
1 1
0 2 1
1 2 
1 3

Out:
1 5
2 5
3 4
3 6
3 6
1 5
*/

/*
In:
5 2
1 1
1 2

Out:
1 0
2 0
*/

Measured memory_bytes: 12828