SegTree

#include <iostream>
#include <vector>
#include <iterator>

using LL = long long;

struct SegmentTree {
    std::vector<LL> tree;
    int size;

    LL combine(const LL & left, const LL & right) {
        return {left + right};
    }

    void build(const std::vector<int> & data, int x, int l, int r) {
        if (r - l == 1) {
            if (l < data.size()) {
                tree[x] = data[l];
            } else {
                tree[x] = 0; // нейтральное значение
            }
            return;
        }
        int m = (l + r) / 2;
        build(data, 2*x+1, l, m);
        build(data, 2*x+2, m, r);
        tree[x] = combine(tree[2*x+1], tree[2*x+2]);
    }

    void build(const std::vector<int> & data) {
        size = 1;
        while (size <= data.size()) {
            size *= 2;
        }
        tree.resize(2 * size);
        build(data, 0, 0, size);
    }

    void set_up(int i, int v) {
        i += size - 1;
        tree[i] = v;
        while (i > 0) {
            i = (i - 1) / 2;
            tree[i] = combine(tree[2*i+1], tree[2*i+2]);
        }
    }

    LL sum_up(int l, int r) {
        LL ans = 0;
        l += size - 1;
        r += size - 2;
        while (l <= r) {
            if (l % 2 == 0) {
                ans += tree[l];
            }
            if (r % 2 != 0) {
                ans += tree[r];
            }
            l = l / 2;
            r = r / 2 - 1;
        }
        return ans;
    }

    void set(int i, int v, int x, int lx, int rx) {
        if (rx - lx == 1) {
            tree[x] = v;
            return;
        }
        int mx = (lx + rx) / 2;
        if (i < mx) {
            set(i, v, 2*x+1, lx, mx);
        } else {
            set(i, v, 2*x+2, mx, rx);
        }
        tree[x] = combine(tree[2*x+1], tree[2*x+2]);
    }

    void set(int i, int v) {
        set(i, v, 0, 0, size);
    }

    LL sum(int l, int r, int x, int lx, int rx) {
        if (l >= rx || r <= lx) {
            return 0;
        }
        if (l <= lx && rx <= r) {
            return tree[x];
        }
        int mx = (lx + rx) / 2;
        LL ls = sum(l, r, 2*x+1, lx, mx);
        LL rs = sum(l, r, 2*x+2, mx, rx);
        return combine(ls, rs);
    }

    LL sum(int l, int r) {
        return sum(l, r, 0, 0, size);
    }

    void print() {
        for(int i=0; i<tree.size(); ++i){
            std::cout << tree[i] << ' ';
        }
        std::cout << '\n';
    }
};

int main() {
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);

    int n, m;
    std::cin >> n >> m;
    std::vector<int> data;
    for(int i = 0; i<n; ++i) {
        int x;
        std::cin >> x;
        data.push_back({x});
    }

    SegmentTree st;
    st.build(data);
    // st.print();

    for(int j=0; j<m; ++j) {
        int t;
        std::cin >> t;
        if (t == 1) {
            int i, v;
            std::cin >> i >> v;
            st.set_up(i, v); // снизу вверх
            // st.set(i, v);
        } else {
            int l, r;
            std::cin >> l >> r;
            std::cout << st.sum_up(l, r) << '\n';  // снизу вверх
            // std::cout << st.sum(l, r) << '\n';
        }
    }

    return 0;
}