//Kami
/*#include<bits/stdc++.h>
#define ll int
using namespace std;
const int N=1e5+5;
int n,ans=0;
ll v[N],s[N];
ll st[4*N],lazy[4*N],b[4*N];

void construct1(int l,int r,int nod)
{
    if(l==r)
    {
        b[nod]=v[l]-s[l+1];
        return;
    }
    if(l>r)
        return;
    int mij=(l+r)/2;
    construct1(l,mij,2*nod);
    construct1(mij+1,r,2*nod+1);
    b[nod]=max(b[2*nod],b[2*nod+1]);
}


void construct2(ll v[],int l,int r,int nod)
{
    if(l==r)
    {
        st[nod]=v[l];
        return;
    }
    if(l>r)
        return;
    int mij=(l+r)/2;
    construct2(v,l,mij,2*nod);
    construct2(v,mij+1,r,2*nod+1);
    st[nod]=st[2*nod]+st[2*nod+1];
}

ll get_sum(int l,int r,int nod,int ql,int qr)
{
    if(l>=ql && r<=qr)
        return st[nod];

    if(r<ql || l>qr)
        return 0;

    int mij=(l+r)/2;
    return get_sum(l,mij,2*nod,ql,qr)+get_sum(mij+1,r,2*nod+1,ql,qr);

}

void update2(int l,int r,int i,int nou,int nod)
{
    if (i < l || i > r)
        return;
    if(l==r)
        {st[nod]+=nou;
        return;
        }
    int mid = (l+r)>>1;
    update2(l, mid, i, nou, 2*nod);
    update2(mid+1, r, i,nou, 2*nod+1);
    st[nod]=st[2*nod]+st[2*nod+1];
}

void find1(int l,int r,int nod,int ql,int qr,ll val)
{
    //if(ans>0)
    //    return;
    if(lazy[nod])
    {
        b[nod]+=lazy[nod];
        if(l!=r){
        lazy[2*nod]+=lazy[nod];
        lazy[2*nod+1]+=lazy[nod];
        }
        lazy[nod]=0;
    }
    if(r<ql || l>qr)
        return;
    if(l>r)
        return;
    if(b[nod]<val)
        return;
    if(l>=ql && r<=qr)
    {
        if(l==r)
        {
            ans=l;
            return;
        }
        int mij=(l+r)/2;
        find1(l,mij,2*nod,ql,qr,val);
        find1(mij+1,r,2*nod+1,ql,qr,val);
        return;
    }
    //partially overlap
    int mij=(l+r)/2;
    if(qr>mij)
        find1(mij+1,r,2*nod+1,ql,qr,val);
    if(ql<=mij)
        find1(l,mij,2*nod,ql,qr,val);
    return;
}

void update(int l,int r,int nod,int ql,int qr,ll add)
{
    if(lazy[nod])
    {
        b[nod]+=lazy[nod];
        if(l!=r){
        lazy[2*nod]+=lazy[nod];
        lazy[2*nod+1]+=lazy[nod];
        }
        lazy[nod]=0;
    }
    if(r<ql || l>qr)
        return;
    if(l>r)
        return;
    if(l>=ql && r<=qr)
    {
        b[nod]+=add;
        if(l!=r){
        lazy[2*nod]+=add;
        lazy[2*nod+1]+=add;
        }
        return;
    }
    int mij=(l+r)/2;
    if(ql<=mij)
        update(l,mij,2*nod,ql,qr,add);
    if(qr>mij)
        update(mij+1,r,2*nod+1,ql,qr,add);
    b[nod]=max(b[2*nod],b[2*nod+1]);
}

main()
{
    freopen("kami.in","r",stdin);
    freopen("kami.out","w",stdout);
    int n,q;
    scanf("%d",&n);
    for(int i=1;i<=n;++i)
        scanf("%d",&v[i]);
    s[n]=v[n];
    for(int i=n-1;i>=1;--i)
        s[i]=s[i+1]+v[i];
    construct1(1,n,1);
    construct2(v,1,n,1);
    //cout<<b[6];
    scanf("%d",&q);
    //cout<<s[1];
    //cout<<st[1];
    while(q--)
    {
        int x,a;
        scanf("%d",&x);
        if(x==1)
        {
            scanf("%d",&a);
            ll s=get_sum(1,n,1,a+1,n);
            s=-s;
            ans=0;
            if(a!=1)
                find1(1,n,1,1,a-1,s);
            else
                ans=0;
            cout<<ans<<'\n';
            //cout<<s<<'\n';
        }
        else
        {
            ll c;
            cin>>a>>c;
            //scanf("%d%lld",&a,&c);
            //cout<<get_sum(1,n,1,1,n)<<' ';
            ll dif=c-v[a];
            update2(1,n,a,c,dif);
            update(1,n,1,a,a,dif);
            if(a!=1)
                update(1,n,1,1,a-1,-dif);
            v[a]=c;
            //cout<<b[2]<<' ';
        }
    }
}*/

#include <bits/stdc++.h>
#define nmax 15005
using namespace std;
ifstream fin ("datorii.in");
ofstream fout ("datorii.out");

int bit[nmax],n;

int f(int index)
{
    return index & (index+1);
}

int g(int index)
{
    return index | (index+1);
}


int sum(int r)
{
    int ret = 0;
    for (; r >= 0; r = f(r) - 1)
        ret += bit[r];
    return ret;
}


int sum(int l, int r)
{
    return sum(r) - sum(l - 1);
}

void add(int idx, int delta)
{
    for (; idx < n; idx = g(idx))
        bit[idx] += delta;
}

int main() {

    int m,x,op,l,r;
	fin>>n>>m;
    for (int i=0;i<n;++i){
        fin>>x;
        add(i,x);
    }
    for (int i=0;i<m;++i)
    {
        fin>>op>>l>>r;
        if (!op)
            add(l-1,-r);
        else
            fout<<sum(l-1,r-1)<< '\n';
    }
    return 0;
}

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

class cmp
{
public:
    bool operator() (const int a, const int b)
    {
        return a>b;
    }
};

int main()
{
    int n,m;
    cin>>n>>m;
    priority_queue<int, vector<int>, cmp> pq;
    for(int i=1;i<=m+1;++i)
    {
        int x;
        cin>>x;
        pq.push(x);
    }
    int x=pq.top();
    cout<<x<<' ';
    pq.pop();
    for(int i=m+2;i<=n;++i)
    {
        int y;
        cin>>y;
        pq.push(y);
        x=pq.top();
        cout<<x<<' ';
        pq.pop();
    }
    while(!pq.empty())
    {
        cout<<pq.top()<<' ';
        pq.pop();
    }

}*/
//Circular RMQ
/*#include<bits/stdc++.h>
#define N 200010
#define DIM 1e9
typedef long long int I64;
using namespace std;
I64 n,v[N];
I64 st[4*N],lazy[4*N];

void construct(I64 v[N],I64 l,I64 r,I64 nod)
{
    if(l==r)
    {
        st[nod]=v[l];
        return;
    }
    if(l>r)
        return;
    I64 mij=(l+r)/2;
    construct(v,l,mij,2*nod);
    construct(v,mij+1,r,2*nod+1);
    st[nod]=min(st[2*nod],st[2*nod+1]);
}

I64 get_min(I64 l,I64 r,I64 nod,I64 ql,I64 qr)
{
    if(lazy[nod])
    {
        st[nod]+=lazy[nod];
        if(l!=r){
        lazy[2*nod]+=lazy[nod];
        lazy[2*nod+1]+=lazy[nod];
        }
        lazy[nod]=0;

    }

    if(l>=ql && r<=qr)
        return st[nod];

    if(r<ql || l>qr)
        return DIM;

    I64 mij=(l+r)/2;
    return min(get_min(l,mij,2*nod,ql,qr),get_min(mij+1,r,2*nod+1,ql,qr));

}

void update(I64 l,I64 r,I64 nod,I64 ql,I64 qr,I64 add)
{
    if(lazy[nod])
    {
        st[nod]+=lazy[nod];
        if(l!=r){
        lazy[2*nod]+=lazy[nod];
        lazy[2*nod+1]+=lazy[nod];
        }
        lazy[nod]=0;
    }
    if(r<ql || l>qr)
        return;
    if(l>r)
        return;
    if(l>=ql && r<=qr)
    {
        st[nod]+=add;
        if(l!=r){
        lazy[2*nod]+=add;
        lazy[2*nod+1]+=add;
        }
        return;
    }
    I64 mij=(l+r)/2;
    update(l,mij,2*nod,ql,qr,add);
    update(mij+1,r,2*nod+1,ql,qr,add);
    st[nod]=min(st[2*nod],st[2*nod+1]);
}

int main()
{
    I64 m;
    cin>>n;
    for(I64 i=1;i<=n;++i)
        cin>>v[i];
    construct(v,1,n,1);
    cin>>m;
    vector<I64> sol;
    while(m-->=0){
        string s,val;
        getline(cin, s);
        stringstream stream(s);
        vector<I64> v1;
        while (getline(stream, val, ' ')) {
            //cout << stoi(val) << endl;
            v1.push_back(stoi(val));
        }
        if(v1.empty())
            continue;
        //cout<<v[0]<<' '<<v[1];
        I64 ql=v1[0]+1,qr=v1[1]+1;
        //cout<<ql<<' '<<qr<<' '<<v1.size()<<'\n';
        if(v1.size()==2)
        {
            if(ql<=qr)
                sol.push_back(get_min(1,n,1,ql,qr));
                //cout<<get_min(1,n,1,ql,qr)<<'\n';
            else
                {//cout<<get_min(1,n,1,ql,n)<<' '<<get_min(1,n,1,1,qr)<<'\n';

                sol.push_back(min(get_min(1,n,1,ql,n),get_min(1,n,1,1,qr)));
                }
        }
        else
        {
            //cout<<v1[2];
            if(ql<=qr)
                update(1,n,1,ql,qr,v1[2]);
            else
            {
                update(1,n,1,ql,n,v1[2]);
                update(1,n,1,1,qr,v1[2]);
            }
        }
        //--m;
    }
    for(const auto& i:sol)
        cout<<i<<'\n';
}*/

/*#include<bits/stdc++.h>
#define N 1000100
typedef long long int I64;
using namespace std;

string s;
I64 n;

struct arb{
    I64 ans;
    I64 desc;
    I64 inc;
}st[4*N];

void build(I64 nod,I64 l,I64 r)
{
    //cout<<nod<<' '<<l<<' '<<r<<endl;
    if(l==r)
    {
        if(s[l-1]=='(')
        {
            st[nod].ans=0;
            st[nod].desc=1;
            st[nod].inc=0;
            return;
        }
        else
        {
            st[nod].ans=0;
            st[nod].desc=0;
            st[nod].inc=1;
            return;
        }
    }
    if(l>r)
        return;
    I64 mid=(l+r)/2;
    build(2*nod,l,mid);
    build(2*nod+1,mid+1,r);
    I64 match=min(st[2*nod].desc,st[2*nod+1].inc);
    st[nod].ans=st[2*nod].ans+st[2*nod+1].ans+match;
    st[nod].desc=st[2*nod].desc+st[2*nod+1].desc-match;
    st[nod].inc=st[2*nod].inc+st[2*nod+1].inc-match;
    return;
}

arb query(I64 nod,I64 l,I64 r,I64 ql,I64 qr)
{
    if(l>r || l>qr || r<ql)
        {
            arb aux;
            aux.ans=0;
            aux.desc=0;
            aux.inc=0;
            return aux;
        }
    if(l>=ql && r<=qr)
        return st[nod];
    I64 mid=(l+r)/2;
    arb ans_left=query(2*nod,l,mid,ql,qr);
    arb ans_right=query(2*nod+1,mid+1,r,ql,qr);
    arb ans_curr;
    I64 match=min(ans_left.desc,ans_right.inc);
    ans_curr.ans=ans_left.ans+ans_right.ans+match;
    ans_curr.desc=ans_left.desc+ans_right.desc-match;
    ans_curr.inc=ans_left.inc+ans_right.inc-match;
    return ans_curr;
}

class InParser {
private:
	FILE *fin;
	char *buff;
	int sp;
	char read_ch() {
		++sp;
		if (sp == 4096) {
			sp = 0;
			fread(buff, 1, 4096, fin);
		}
		return buff[sp];
	}
public:
	InParser(const char* nume) {
		fin = fopen(nume, "r");
		buff = new char[4096]();
		sp = 4095;
	}

	InParser& operator >> (I64& n) {
		char c;
		n = 0;
		while (!isdigit(c = read_ch()) && c != '-');
		I64 sgn = 1;
		if (c == '-') {
			n = 0;
			sgn = -1;
		} else {
			n = c - '0';
		}
		while (isdigit(c = read_ch())) {
            n = 10 * n + (I64)c - '0';
		}
		n *= sgn;
		return *this;
	}
	InParser& operator >> (string& str)
	{
	    char c;
	    while(!isdigit(c = read_ch()) && c!='\n')
            {
                str+=c;
                //cout<<c;
            }
        return *this;
	}
};


void read()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    I64 q,a,b;
    cin>>s;
    n=(I64)s.size();
    cin>>q;
    build(1,1,n);
    while(q--)
    {
        cin>>a>>b;
        cout<<2*query(1,1,n,a,b).ans<<endl;
        //cout<<a<<b<<endl;
    }
}

int main()
{
    read();
    //cout<<n;
    //build(1,1,n);
}*/