#include<bits/stdc++.h>
using namespace std;

extern inline unsigned int xor128(void){
  static unsigned int x=123456789,y=362436069,z=521288629,w=88675123; 
  unsigned int t=x^(x<<11);
  x=y; y=z; z=w;
  return w=(w^(w>>19))^(t^(t>>8)); 
}

template <typename T>
class Treap{
public:
  Treap* l;
  Treap* r;
  int cnt;
  int pri;
  T value;
  Treap(){
  }
  Treap(T v){
    value=v;
    cnt=1;
    pri=xor128();
    l=r=NULL;
  }
};

template <typename T >
class Vectree{
private:

  int count(Treap<T>* t){ return !t ? 0:t->cnt; }

  Treap<T>* update(Treap<T>* t){
    t->cnt = count(t->l) + count(t->r) + 1;
    return t;
  }

  
  Treap<T>* merge(Treap<T>* l,Treap<T>* r){
    if( !l || !r ) return !l ? r : l;
    if( l->pri > r ->pri ){
      l->r = merge(l->r,r);
      return update(l);
    } else {
      r->l = merge(l,r->l);
      return update(r);
    }
  }

  typedef pair< Treap<T>* , Treap<T>* > pnn;
  pnn split(Treap<T>* t,int k){
    if( !t ) return pnn(NULL,NULL);
    if( k <= count(t->l) ){
      pnn s = split(t->l,k);
      t->l = s.second;
      return make_pair(s.first,update(t));
    } else {
      pnn s = split(t->r,k - count(t->l) - 1);
      t->r = s.first;
      return make_pair(update(t),s.second);
    }
  }
  
  int size_num;
  Treap<T> *root;
public:
  Vectree(){
    size_num=0;
    root=NULL;
  }
  Vectree(int n, T t=T() ){
    size_num=0;
    root=NULL;
    resize(n,t);
  }
  
  int size();

  void push_back(T);
  void pop_back();
  void insert(int,T);
  void erase(int);

  void resize(int,T);
  void clear();
  int lower_bound(T);
  T& operator [] (int x);
};


template <typename T>
int Vectree <T> :: size(){
  return size_num;
}

template <typename T>
void Vectree <T> :: erase(int index){
  auto p=split( root, index + 1 );
  auto q=split( p.first, index);
  root = merge(q.first,p.second);
  size_num--;
}

template <typename T>
void Vectree <T> :: insert(int index,T v){
  auto p=split( root, index );

  p.first = merge( p.first, new Treap<T>(v) );

  root = merge( p.first, p.second );
  size_num++;
}

template <typename T>
void Vectree <T> :: push_back(T v){
  insert( size_num, v );
}

template <typename T>
void Vectree <T> :: pop_back(){
  erase( size_num );
}

template <typename T>
void Vectree <T> :: resize(int n,T v){
  while( size() < n ){
    insert(0,v);
  }
}

template <typename T>
void Vectree <T> :: clear(){
  while( size() > 0 ){
    erase(0);
  }
}

template <typename T>
int Vectree <T> :: lower_bound(T t){
  auto cur=root;
  int res=0;
  while(cur!=NULL){
    if(cur->value >= t){
      cur=cur->l;
    }else{
      res+=count(cur->l)+1;
      cur=cur->r;
    }
  }
  return res;
}

template <typename T>
T& Vectree<T> :: operator [] (int x){
  auto p=split(root,x);
  auto q=split(p.second,1);
  root=merge(p.first, merge(q.first,q.second) );
  return q.first->value;
}

int main(){
  typedef long long ll;
  typedef pair<ll,ll> P;
  int N,C;
  cin>>N>>C;
  Vectree< P > t;
  
  for(int i=0;i<N;i++){
    t.push_back( P(0,i) );
  }
  
  vector< ll > a(N,0);
  while(C--){
    int type;
    cin>>type;
    if(type==0){
      int id,score;
      cin>>id>>score;
      id--;
      
      int target=t.lower_bound( P(a[id],id) );
      t.erase(target);
      a[id]-=score;
      t.insert( t.lower_bound(P(a[id],id)) , P(a[id],id) );
    }else{
      int id;
      cin>>id;
      id--;
      cout<<t[id].second+1<<' '<<-t[id].first<<endl;
    }
  }
  return 0;
}

Measured memory_bytes: 12860