#include <cassert>
#include <limits>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#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>
 
#define rep(i, a, b) for (long long (i) = (a); i < (b); i++)
#define all(i) i.begin(), i.end()
#define debug(i) std::cerr << "debug " <<"LINE:"<<__LINE__<<"  "<< #i <<":"<< i << std::endl

 
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 ((a == 0)||(mod!=-1&&a%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<ll, ll>;

//動的セグ木 実装上各項を初期化することはできない
//逆元が存在すれば初期化可能だけどmin,maxとかなら無理
template<typename T>
class DynamicSegmentTree{
  private:

  long long n0;
  std::function<T(T,T)> fn;
  T init;

  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 init;
    }

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

    return fn(lval,rval);
  }

  public:

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

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

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

      if(i<mid){
        if(!now->left){
          now->left=std::make_shared<Node>(init);
        }

        now=now->left;
        now->value=fn(now->value,val);

        r=mid;
      }else{
        if(!now->right){
          now->right=std::make_shared<Node>(init);
        }

        now=now->right;
        now->value=fn(now->value,val);

        l=mid;
      }
    }
  }

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

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

  DynamicSegmentTree<ll> seg(MOD,0,[](ll a,ll b){return a+b;});

  ll n;
  std::cin>>n;

  ll ans=0;

  rep(_,0,n){
    ll q,x,y;
    std::cin>>q>>x>>y;

    if(q==0){
      seg.update(x,y);
    }else{
      ans+=seg.query(x,y+1);
    }
  }

  std::cout<<ans<<"\n";

  return 0;
}