#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <utility>
#include <algorithm>
#include <numeric>
#include <functional>
#include <queue>
#include <stack>
#include <deque>
#include <cmath>
using namespace std;
#define int long long
using ll=long long;
using vi=vector<int>;
using pii=pair<int,int>;
#define ALL(c) begin(c),end(c)
#define RALL(c) rbegin(c),rend(c)
#define ITR(i,b,e) for(auto i=(b);i!=(e);++i)
#define FORE(x,c) for(auto &x:c)
#define REPF(i,a,n) for(int i=a,i##len=(int)(n);i<i##len;++i)
#define REP(i,n) REPF(i,0,n)
#define REPR(i,n) for(int i=(int)(n);i>=0;--i)
#define SZ(c) ((int)c.size())
#define CONTAIN(c,x) (c.find(x)!=end(c))
#define OUTOFRANGE(y,x,h,w) ((y)<0||(x)<0||(y)>=(h)||(x)>=(w))
#define dump(...)
const signed INF_=1001001001; const long long INF=1001001001001001001LL;
const int DX[9]={0,1,0,-1,1,1,-1,-1,0},DY[9]={-1,0,1,0,-1,1,1,-1,0};
template<class T> ostream& operator<<(ostream &os,const vector<T> &v) {
    ITR(i,begin(v),end(v))os<<*i<<(i==end(v)-1?"":" ");return os;}
template<class T> istream& operator>>(istream &is,vector<T> &v) {
    ITR(i,begin(v),end(v)) is>>*i;return is;}
template<class T,class U> istream& operator>>(istream &is, pair<T,U> &p) {
    is>>p.first>>p.second;return is;}
template<class T, class U> bool chmax(T &a,const U &b){return a<b?a=b,1:0;}
template<class T, class U> bool chmin(T &a,const U &b){return a>b?a=b,1:0;}
template<class T> using heap=priority_queue<T,vector<T>,greater<T>>;
struct before_main_function {
    before_main_function() {
        cin.tie(0); ios::sync_with_stdio(false);
        cout << setprecision(15) << fixed;
        #define endl "\n"
    }
} before_main_function;
//------------------8<------------------------------------8<--------------------

template<typename Monoid>
struct SegmentTree {
    using T = typename Monoid::T;
    const size_t n;
    vector<T> t;
    void prop_to(std::size_t i) { t[i] = Monoid::op(t[i << 1], t[i << 1 | 1]); }
    SegmentTree(size_t n, const T& v = Monoid::identity()) : n(n), t(n << 1, v) {}
    template <class InputIt>
    SegmentTree(InputIt first, InputIt last) : n(distance(first, last)), t(n << 1, Monoid::identity()) {
        copy(first, last, begin(t) + n);
        for (size_t i = n; i > 0; i--) prop_to(i);
    }
    void update(size_t i, const T& v) {
        t[i += n] = v;
        while (i >>= 1) prop_to(i);
    }
    T query(size_t l, size_t r) {
        T res = Monoid::identity();
        for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
            if (l & 1) res = Monoid::op(res, t[l++]);
            if (r & 1) res = Monoid::op(res, t[--r]);
        }
        return res;
    }
    T get(size_t i) { return t[i + n]; }
};

struct RMQ {
    using T = int;
    static T op(T a, T b) { return min(a, b); }
    static constexpr T identity() { return (1LL << 31) - 1; }
};

struct RSQ {
    using T = int;
    static T op(T a, T b) { return a + b; }
    static constexpr T identity() { return 0; }
};

signed main() {
    int n, q;
    cin >> n >> q;
    SegmentTree<RSQ> seg(n);
    while (q--) {
        int com, x, y;
        cin >> com >> x >> y;
        if (com) cout << seg.query(x - 1, y) << endl;
        else seg.update(x - 1, seg.get(x - 1) + y);
    }
    return 0;
}



Measured memory_bytes: 4400