#include <cassert>
#include <algorithm>
#include <array>
#include <bitset>
#include <cctype>
#include <cstdint>
#include <cmath>
#include <complex>
#include <chrono>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#include <random>
#include <memory>
#include <utility>
#include <limits>
#include "limits.h"
 
#define rep(i, a, b) for (long long (i) = (a); (i) < (b); (i)++)
#define all(i) i.begin(), i.end()
#define debug(...) std::cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)

void debug_out(){std::cerr<<std::endl;}

template<typename Head,typename... Tail>
void debug_out(Head h,Tail... t){
  std::cerr<<" "<<h;
  debug_out(t...);
}
 
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, std::pair<T1, T2> pa) {
  return os << pa.first << " " << pa.second;
}
 
template <typename T>
std::ostream& operator<<(std::ostream& os, std::vector<T> vec) {
  for (int i = 0; i < vec.size(); i++)os << vec[i] << (i + 1 == vec.size() ? "" : " ");
  return os;
}
 
template<typename T1,typename T2>
inline bool chmax(T1& a,T2 b){return a<b && (a=b,true);}
 
template<typename T1,typename T2>
inline bool chmin(T1& a,T2 b){return a>b && (a=b,true);}
 
long long pow_mod(long long a, long long b, long long mod=-1) {
  if(b==0)return 1;
  if ((a == 0)||(mod!=-1&&(a+mod)%mod==0)) {
    return 0;
  }
  long long x = 1;
  while (b > 0) {
    if (b & 1) {
      x = (mod!=-1)?(x * a) % mod:x*a;
    }
    a = (mod!=-1)?(a * a) % mod:a*a;
    b >>= 1;
  }
  return x;
}

// const long long MOD = 998244353;
const long long MOD = 1e9 + 7;

using ll = long long;
using P=std::pair<long long,long long>;

//動的セグ木 
//可換演算かつupdateで代入操作をしないときの軽い実装
template<typename T,typename F>
class DynamicSegmentTree{
  private:

  //using F=std::function<T(T,T)>;//c++17ならtemplateで上手くやって

  long long n,n0;
  F f;
  T id;

  class Node{
    public:
    std::shared_ptr<Node> left,right;
    T value;

    Node(T i):value(i),left(),right(){}
  };

  std::shared_ptr<Node> root;

  T query(long long a,long long b,const std::shared_ptr<Node>& now,long long l,long long r){
    if(a<=l&&r<=b)return now->value;
    if(b<=l||r<=a)return id;

    T lval=(now->left)?query(a,b,now->left,l,l+(r-l)/2):id;
    T rval=(now->right)?query(a,b,now->right,l+(r-l)/2,r):id;

    return f(lval,rval);
  }

  public:

  //要素数の最大値n,単位元i,演算fを渡す
  DynamicSegmentTree(long long n_,T i,F f):n(n_),id(i),f(f),root(new Node(id)){
    n0=1;
    while(n0<n_)n0<<=1;
  }

  // 更新 Ai=fn(Ai,val) を行う
  void update(long long i,T val){
    assert(0<=i&&i<n);
    std::shared_ptr<Node> now(root);

    long long l=0,r=n0;
    while(r-l>1){
      now->value=f(now->value,val);
      long long mid=l+(r-l)/2;

      if(i<mid){
        if(!now->left)now->left=std::make_shared<Node>(id);
        now=now->left;r=mid;
      }else{
        if(!now->right)now->right=std::make_shared<Node>(id);
        now=now->right;l=mid;
      }
    }
    now->value=f(now->value,val);
  }

  //[a,b)の区間演算結果を返す
  T query(long long a,long long b){
    assert(0<=a&&b<=n);
    return query(a,b,root,0,n0);
  }
};

int main() {
  std::cin.tie(nullptr);
  std::ios::sync_with_stdio(false);

  ll n,q;
  std::cin>>n>>q;

  auto sum=[&](const ll& a,const ll& b){return a+b;};

  DynamicSegmentTree<ll,decltype(sum)> seg(n,0ll,sum);

  rep(i,0,q){
    ll mode,x,y;
    std::cin>>mode>>x>>y;
    x--;
    if(mode==0){
      seg.update(x,y);
    }else{
      std::cout<<seg.query(x,y)<<"\n";
    }
  }

  return 0;
}



Measured memory_bytes: 10548