// Original C++ solution (slower):
#include<iostream>

using namespace std;

int bit[100000+1],n;

int sum(int i){

  int s=0;

  while(i>0){

    s+=bit[i];

    i-=i&-i;

  }

  return s;

}

void add(int i,int x){

  while(i<=n){

    bit[i]+=x;

    i+=i&-i;

  }

}

int main(){

  int q;

  cin >> n>>q;

  fill(bit,bit+100000+1,0);

  int a,b,c;

  while(q--){

    cin >> a >> b >> c;

    if(a==0) add(b,c);

    else{

      if(b==0) cout << sum(c) << endl;

      else cout << sum(c)-sum(b-1)<<endl;

    }

  }

}

// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

using Int = long long;

//BEGIN CUT HERE

template<typename T,size_t X>

struct BinaryTrie{

  struct Node{

    bool f;

    size_t cnt;

    Node *p,*l,*r;

    Node(bool f,Node* p):f(f),cnt(0),p(p){l=r=nullptr;}

  };

  

  T acc;

  Node *root;

  BinaryTrie():acc(0){root=emplace(0,nullptr);}

  

  inline Node* emplace(bool f,Node* p){

    return new Node(f,p);

  }



  inline size_t count(Node* a){

    return a?a->cnt:0;

  }

  

  void add(const T b,size_t k=1){

    const T nb=b^acc;

    Node* a=root;

    for(int i=X-1;i>=0;i--){

      bool f=(nb>>i)&1;

      if(!f&&!a->l) a->l=emplace(f,a);

      if( f&&!a->r) a->r=emplace(f,a);

      a=f?a->r:a->l;

    }

    a->cnt+=k;    

    while((a=a->p)) a->cnt=count(a->l)+count(a->r);    

  }



  inline void update(const T b){acc^=b;}



  Node* find(const T b){

    const T nb=b^acc;

    Node* a=root;

    for(int i=X-1;i>=0;i--){

      bool f=(nb>>i)&1;

      a=f?a->r:a->l;

      if(!a) return a;

    }

    return a;

  }



  Node* check(Node *a){

    if(!a||count(a)) return a;

    delete(a);

    return nullptr;

  }



  void sub(Node* a,size_t k=1){

    assert(a&&a->cnt>=k);

    a->cnt-=k;

    while((a=a->p)){

      a->l=check(a->l);

      a->r=check(a->r);

      a->cnt=count(a->l)+count(a->r);

    }

  }

  

  Node* xmax(const T b){

    assert(count(root));

    const T nb=b^acc;

    Node* a=root;    

    for(int i=X-1;i>=0;i--){

      bool f=(nb>>i)&1;

      a=(!a->l||(!f&&a->r))?a->r:a->l;

    }

    return a;

  }



  int xmin(const T b){

    return xmax(~b&((T(1)<<X)-1));

  }



  Node* ge(Node *a){

    if(a&&(a->r||a->l)) return a->l?a->l:a->r;

    return a;

  }

  

  Node* next(Node* a){

    while(a->p){

      if(a->p->l==a) return ge(a->p->r);

      a=a->p;

    }

    return nullptr;

  }

  

  Node* lower_bound(const T b){

    const T nb=b^acc;

    Node* a=root;

    for(int i=X-1;i>=0;i--){

      bool f=(nb>>i)&1;

      if(!f&&a->l){a=a->l;continue;}

      if( f&&a->r){a=a->r;continue;}

      if(f) return next(a);

      return ge(a->r);

    }

    return a;

  }



  int upper_bound(const T b){

    return lower_bound(b+1);

  }

  

  T val(Node* a){

    T res(0);

    for(int i=0;i<(int)X;i++){

      bool f=(acc>>i)&1;

      res|=(T(a->f)<<i)^f;      

      a=a->p;

    }

    return res^acc;

  }



  Node* find_by_order(size_t k){

    Node *a=root;

    if(count(a)<=k) return nullptr;

    for(int i=X-1;i>=0;i--){

      bool f=(acc>>i)&1;

      if(count(f?a->r:a->l)<=k){

        k-=count(f?a->r:a->l);

        a=f?a->l:a->r;

      }else{

        a=f?a->r:a->l;

      }

    }

    return a;

  }



  size_t order_of_key(const T b){

    const T nb=b^acc;

    Node *a=root;

    size_t res=0;

    for(int i=X-1;i>=0;i--){

      bool f=(nb>>i)&1;

      if(f) res+=count(a->l);      

      a=f?a->r:a->l;

      if(!a) break;

    }

    return res;

  }

};

//END CUT HERE

signed JAG2013SUMMERWARMINGUP_F(){

  int n;

  scanf("%d",&n);

  vector<int> a(n);

  for(int i=0;i<n;i++) scanf("%d",&a[i]);

  vector<int> s(n+1,0);

  for(int i=0;i<n;i++) s[i+1]=s[i]^a[i];

  BinaryTrie<int, 30> bt;

  using ull = unsigned long long;

  map<ull, int> r;

  bt.add(0);

  r[(ull)bt.find(0)]=0;

  int ans=-1,idx=-1,idy=-1;

  for(int i=0;i<n;i++){

    int k=r[(ull)bt.xmax(a[i])];

    int res=s[i+1]^s[k];

    if(ans<res||(ans==res&&idx>k)){

      ans=res;

      idx=k;

      idy=i;

    }

    bt.update(a[i]);

    bt.add(0);

    if(!r.count((ull)bt.find(0))) r[(ull)bt.find(0)]=i+1;

  }

  printf("%d %d %d\n",ans,idx+1,idy+1);

  return 0;

}

/*

  verified on 2018/10/24

  https://beta.atcoder.jp/contests/jag2013summer-warmingup/tasks/icpc2013summer_warmingUp_f

*/



signed ARC033_C(){

  int q;

  scanf("%d",&q);

  BinaryTrie<int, 30> bt;

  while(q--){

    int t,x;

    scanf("%d %d",&t,&x);

    if(t==1) bt.add(x);

    if(t==2){

      auto k=bt.find_by_order(x-1);

      printf("%d\n",bt.val(k));

      bt.sub(k);

    }

  }

  return 0;

}



/*

  verified on 2018/10/24

  https://beta.atcoder.jp/contests/arc033/tasks/arc033_3

*/



signed AOJ_DSL2B(){

  int n,q;

  scanf("%d %d",&n,&q);

  BinaryTrie<int, 30> bt;

  for(int i=0;i<q;i++){

    int c,x,y;

    scanf("%d %d %d",&c,&x,&y);

    if(c) printf("%zd\n",bt.order_of_key(y+1)-bt.order_of_key(x));

    else bt.add(x,y);

  }

  return 0;

}

/*

  verified on 2018/10/24

  http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_2_B&lang=jp

*/



signed main(){

  //JAG2013SUMMERWARMINGUP_F();

  //ARC033_C();

  AOJ_DSL2B();

  return 0;

}




// Fastest known solution for this problem: