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

#define all(v) v.begin(),v.end()
using ll = long long;
using ull = unsigned long long;
using lll = __int128;
using vll=vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<ll,ll>;
using vp=vector<pair<ll, ll>>;
//using mint=modint1000000007;
//using mint=modint998244353;

const ll INF=1ll<<60;
ll mod10=1e9+7;
ll mod99=998244353;
const double PI = acos(-1);

#define rep(i,n) for (ll i=0;i<n;++i)
#define per(i,n) for(ll i=n-1;i>=0;--i)
#define rep2(i,a,n) for (ll i=a;i<n;++i)
#define per2(i,a,n) for (ll i=a;i>=n;--i)

template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return true; } return false; }

template<typename monoid>
struct Dynamicsegtree{
    using  S =  typename monoid::Type;
    ll N;
    struct Node{
        S val;
        long long l=-1, r=-1;
        long long par=-1;
        Node(S v,ll pa) :val(v),par(pa) {};
    };
    vector<Node> nodes;
    Dynamicsegtree(long long n) : N(n){
        nodes.push_back(Node(monoid::id(),-1));
    }

    void set(long long i,S v){
        ll l=0,r=N;
        long long now=0;
        while(l+1<r){
            ll m=(r+l)/2;
            if(i<m){
                if(nodes[now].l==-1){
                    nodes[now].l=nodes.size();
                    nodes.push_back(Node(monoid::id(),now));
                }
                now=nodes[now].l;
                r=m;
            }else{
                if(nodes[now].r==-1){
                    nodes[now].r=nodes.size();
                    nodes.push_back(Node(monoid::id(),now));
                }
                now=nodes[now].r;
                l=m;
            }
        }
        nodes[now].val=v;
        while(now!=0){
            now=nodes[now].par;
            S v=monoid::id();
            if(nodes[now].l!=-1) v=monoid::op(nodes[nodes[now].l].val,v);
            if(nodes[now].r!=-1) v=monoid::op(v,nodes[nodes[now].r].val);
            nodes[now].val=v;
        }
    }

    S get(long long i){
        long long l=0,r=N;
        int now=0;
        while(l+1<r){
            ll m=(r+l)/2;
            if(i<m){
                if(nodes[now].l==-1){
                    nodes[now].l=nodes.size();
                    nodes.push_back(Node(monoid::id(),now));
                }
                now=nodes[now].l;
                r=m;
            }else{
                if(nodes[now].r==-1){
                    nodes[now].r=nodes.size();
                    nodes.push_back(Node(monoid::id(),now));
                }
                now=nodes[now].r;
                l=m;
            }
        }        
        return nodes[now].val;
    }

    S fold(long long l,long long r){return fold(l,r,0,N,0);}
    S fold(long long l,long long r,long long a,long long b,long long now){
        if(b<=l||r<=a) return monoid::id();
        else if(l<=a&&b<=r) return nodes[now].val;
        else{
            ll m=(a+b)/2;
            S v=monoid::id();
            if(nodes[now].l!=-1){
                v=monoid::op(fold(l,r,a,m,nodes[now].l),v);
            }
            if(nodes[now].r!=-1){
                v=monoid::op(v,fold(l,r,m,b,nodes[now].r));
            }
            return v;
        }
    }


};





struct monoid{
    using Type = long long;
    static Type op(Type a,Type b){
        return a+b;
    }
    static Type id(){return 0;}
};




bool solve(){
    ll Q;cin>>Q;
    ll ans=0;
    Dynamicsegtree<monoid> seg(1e9+10+5);
    while(Q--){
        ll t;cin>>t;
        if(t==0){
            ll x,y;cin>>x>>y;
            seg.set(x,seg.get(x)+y);
        }else{
            ll l,r;cin>>l>>r;
            ans+=seg.fold(l,r+1);
        }
    }
    cout << ans << endl;
    return 0;
}



int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    ll T=1;//cin>>T;
    rep(i,T) solve();
}