#include <bits/stdc++.h>

#define fst(t) std::get<0>(t)
#define snd(t) std::get<1>(t)
#define thd(t) std::get<2>(t)
#define unless(p) if(!(p))
#define until(p) while(!(p))

using ll = std::int64_t;
using T = std::tuple<int, int, int>;

int N;
T query[100100];
std::vector<int> ps;

struct SegmentTree{
    int numLeaves;
    std::vector<ll> data;

    SegmentTree(int n){
        numLeaves = 1;
        while(numLeaves < n){
            numLeaves *= 2;
        }

        data.assign(numLeaves * 2, 0);
    }

    void add(int k, int v){
        k += numLeaves;
        data[k] += v;

        while(k > 1){
            k /= 2;
            data[k] = data[k*2] + data[k*2+1];
        }
    }

    ll sum(int l, int r){
        l += numLeaves;
        r += numLeaves;

        ll s = 0;

        for(;l<r;l/=2,r/=2){
            if(l & 1){
                s += data[l];
                l += 1;
            }
            if(r & 1){
                r -= 1;
                s += data[r];
            }
        }

        return s;
    }
};

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

    std::cin >> N;

    for(int i=0;i<N;++i){
        int a, b, c;
        std::cin >> a >> b >> c;

        query[i] = std::make_tuple(a, b, c);

        if(a == 0){
            ps.emplace_back(b);
        }
    }

    std::sort(ps.begin(), ps.end());
    ps.erase(std::unique(ps.begin(), ps.end()), ps.end());

    SegmentTree seg(ps.size());
    ll sum = 0;

    for(int i=0;i<N;++i){
        int a, b, c;
        std::tie(a, b, c) = query[i];

        if(a == 0){
            int j = std::lower_bound(ps.begin(), ps.end(), b) - ps.begin();
            seg.add(j, c);
        }else{
            int lb = std::lower_bound(ps.begin(), ps.end(), b) - ps.begin(),
                ub = std::upper_bound(ps.begin(), ps.end(), c) - ps.begin();
            sum += seg.sum(lb, ub);
        }
    }

    std::cout << sum << std::endl;
}