#include <fstream>
#include <vector>
 
class SegmentTree {
protected:
    std::vector<int> tree;
    int length;
 
    void build(const std::vector<int> &nums, int node, int l, int r) {
        if (l == r) {
            tree[node] = nums[l];
            return;
        }
 
        int mid = l + (r - l) / 2;
        build(nums, node * 2 + 1, l, mid);
        build(nums, node * 2 + 2, mid + 1, r);
        tree[node] = tree[node * 2 + 1] + tree[node * 2 + 2];
    }
 
    long long sum_range(int node, int l, int r, int ql, int qr) {
        if (ql > qr) {
            return 0;
        }
 
        if (l == ql && r == qr) {
        
            return tree[node];
        }
 
        int mid = l + (r - l) / 2;
 
        long long s = 0;
        auto new_qr = std::min(qr, mid);
        if (ql <= new_qr) {
            s += sum_range(2 * node + 1, l, mid, ql, new_qr);
        }
        auto new_ql = std::max(ql, mid + 1);
        if (new_ql <= qr) {
            s += sum_range(2 * node + 2, mid + 1, r, new_ql, qr);
        }
 
        return s;
    }
 
    void subtract(int index, int val, int node, int l, int r) {
        if (l == r) {
         
            tree[node] -= val;
            return;
        }
 
        int mid = l + (r - l) / 2;
 
        if (index <= mid) {
            subtract(index, val, 2 * node + 1, l, mid);
        } else {
            subtract(index, val, 2 * node + 2, mid + 1, r);
        }
 
        tree[node] = tree[node * 2 + 1] + tree[node * 2 + 2];
    }
 
public:
    SegmentTree(const std::vector<int> &nums) : length(nums.size()) {
        tree.resize(4 * nums.size());
        build(nums, 0, 0, length - 1);
    }
 
    long long sum_range(int ql, int qr) {
        return sum_range(0, 0, length - 1, ql, qr);
    }
 
    void subtract(int index, int val) { subtract(index, val, 0, 0, length - 1); }
};
 
int main() {
    std::ifstream ifs("datorii.in");
 
    int n, m;
    ifs >> n >> m;
 
    std::vector<int> nums(n);
 
    for (int i = 0; i < n; ++i) {
        ifs >> nums[i];
    }
 
    SegmentTree segment_tree(nums);
 
    std::ofstream ofs("datorii.out");
 
    for (int q = 0; q < m; ++q) {
        int op, a1, a2;
        ifs >> op >> a1 >> a2;
 
        if (op == 0) {
            segment_tree.subtract(a1 - 1, a2);
        } else {
            ofs << segment_tree.sum_range(a1 - 1, a2 - 1) << '\n';
        }
    }
 
    ifs.close();
    ofs.close();
 
    return 0;
}