#include <fstream>

using namespace std;

typedef struct _Nod{
    struct _Nod *left;
    struct _Nod *right;
    int sum;
} Nod;

Nod* root;
int n, m;

void addValue(int val, int ind, int min, int max, Nod* curr);
int sumInInterval(int imin, int imax, int wmin, int wmax, Nod *curr);

int main()
{
    ifstream fin("datorii.in");
    ofstream fout("datorii.out");
   
    root = new Nod;
    root->left = NULL;
    root->right = NULL;
    root->sum = 0;
    
    fin >> n;
    fin >> m;
    
    for(int i = 1; i <= n; i++) {
        int t;
        fin >> t;
        addValue(t, i, 1, n, root);
    }
    for(int i = 1; i <= m; i++) {
        int op;
        fin >> op;
        if(op == 1) {
            int p, q;
            fin >> p;
            fin >> q;
            fout << sumInInterval(p, q, 1, n, root) << endl;
            
        } else {
            int t, v;
            fin >> t;
            fin >> v;
            addValue(-v, t, 1, n, root);
        }
    }
    return 0;
}

void addValue(int val, int ind, int min, int max, Nod* curr)
{
    curr->sum += val;
    if (min == max)
        return;
    
    if (ind <= (max+min)/2) {
        if (NULL == curr->left) {
            curr->left = new Nod;
            curr->left->sum = 0;
            curr->left->left = NULL;
            curr->left->right = NULL;
        }
        addValue(val, ind, min, (max+min)/2, curr->left);
    } else {
        if (NULL == curr->right) {
            curr->right = new Nod;
            curr->right->sum = 0;
            curr->right->left = NULL;
            curr->right->right = NULL;
        }
        addValue(val, ind, (max+min)/2+1, max, curr->right);
    }
}

int sumInInterval(int imin, int imax, int wmin, int wmax, Nod *curr)
{
    if (imin == wmin && imax == wmax)
        return curr->sum;
    
    if (imin <= (wmax+wmin)/2) {
        if (imax <= (wmax+wmin)/2) {
            return sumInInterval(imin, imax, wmin, (wmax+wmin)/2, curr->left);
        } else {
            int l, r;
            l = sumInInterval(imin, (wmax+wmin)/2, wmin, (wmax+wmin)/2, curr->left);
            r = sumInInterval((wmax+wmin)/2+1, imax, (wmax+wmin)/2+1, wmax, curr->right);
            return l+r;
        }
    } else {
        return sumInInterval(imin, imax, (wmax+wmin)/2+1, wmax, curr->right);
    }
}