#include <cstdio>
using namespace std;
const int MAXN = 5e5 + 10;
int arr[MAXN];
namespace splay {
const int VAL_MAX = MAXN;
const int VAL_MIN = -VAL_MAX;
struct splay_tree {
    struct node {
        node *p, *lc, *rc;
        int value;
        int count = 0, size = 0;
    };
    node *root = nullptr;
    inline void insert(int val) {
        if (root == nullptr) {
            root = create_node(val);
            return;
        }
        node *cur = root, *pre = nullptr;
        while (true) {
            if (cur->value == val) {
                cur->count++;
                maintain_size(cur);
                maintain_size(pre);
                splay(cur);
                return;
            }
            pre = cur;
            if (cur->value < val) {
                cur = cur->rc;
            } else {
                cur = cur->lc;
            }
            if (cur == nullptr) {
                cur = create_node(val, pre);
                if (pre->value < val) {
                    pre->rc = cur;
                } else {
                    pre->lc = cur;
                }
                maintain_size(cur);
                maintain_size(pre);
                splay(cur);
                return;
            }
        }
    }
    inline void erase(int val) {
        insert(val);
        if (root->count > 2) {
            root->count -= 2;
            maintain_size(root);
            return;
        }
        if (root->lc == nullptr && root->rc == nullptr) {
            delete root;
            root = nullptr;
            return;
        }
        if (root->lc == nullptr) {
            root = root->rc;
            delete root->p;
            root->p = nullptr;
            return;
        }
        if (root->rc == nullptr) {
            root = root->lc;
            delete root->p;
            root->p = nullptr;
            return;
        }
        node *rt = root;
        node *cur = root->lc;
        while (cur->rc != nullptr) {
            cur = cur->rc;
        }
        splay(cur);
        if (rt->rc != nullptr) {
            rt->rc->p = cur;
        }
        cur->rc = rt->rc;
        maintain_size(root);
        delete rt;
    }
    inline int is_exist(int val) {
        insert(val);
        int sz = root->count;
        erase(val);
        return sz > 1;
    }
    inline int get_by_rank(int rank) {
        node *cur = root;
        while (cur != nullptr) {
            if (cur->lc != nullptr && rank <= cur->lc->size) {
                cur = cur->lc;
            } else {
                rank -= cur->count;
                rank -= size_or_null_zero(cur->lc);
                if (rank <= 0) {
                    splay(cur);
                    return cur->value;
                }
                cur = cur->rc;
            }
        }
        return -1;
    }

private:
    inline int is_lc(node *cur) {
        if (cur == nullptr || cur->p == nullptr) {
            return 0;
        }
        return cur == cur->p->lc ? 1 : -1;
    }
    inline void rotate(node *cur) {
        int ch = is_lc(cur);
        if (ch == 0) {
            return;
        }
        node *p = cur->p;
        node *pp = p->p;
        int chp = is_lc(p);
        cur->p = pp;
        p->p = cur;
        if (ch == 1) {
            p->lc = cur->rc;
            if (cur->rc != nullptr) {
                cur->rc->p = p;
            }
            cur->rc = p;
        } else {
            p->rc = cur->lc;
            if (cur->lc != nullptr) {
                cur->lc->p = p;
            }
            cur->lc = p;
        }
        if (pp != nullptr) {
            if (chp == 1) {
                pp->lc = cur;
            } else {
                pp->rc = cur;
            }
        }
        maintain_size(p);
        maintain_size(cur);
    }
    inline void splay(node *cur) {
        if (cur == nullptr) {
            return;
        }
        node *p = cur->p;
        while (p != nullptr) {
            if (p->p != nullptr) {
                if (is_lc(cur) == is_lc(p)) {
                    rotate(p);
                } else {
                    rotate(cur);
                }
            }
            rotate(cur);
            p = cur->p;
        }
        root = cur;
    }
    inline node *create_node(int val = 0, node *p = nullptr, node *lc = nullptr, node *rc = nullptr) {
        node *nd = new node;
        nd->count = 1;
        nd->size = 1;
        nd->value = val;
        nd->p = p;
        nd->lc = lc;
        nd->rc = rc;
        return nd;
    }
    inline int size_or_null_zero(node *p) { return p == nullptr ? 0 : p->size; }
    inline void maintain_size(node *p) {
        if (p == nullptr) {
            return;
        }
        p->size = p->count + size_or_null_zero(p->lc) + size_or_null_zero(p->rc);
    }
};
} // namespace splay
splay::splay_tree t;
const char opts[] = "QCID";
inline char get() {
    char ch = getchar();
    while (1) {
        for (const char &c : opts) {
            if (c == ch) {
                return ch;
            }
        }
        ch = getchar();
    }
}
long long sum = 0;
int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i) {
        scanf("%d", arr + i);
        t.insert(i);
        sum += arr[i];
    }
    long long y;
    for (int i = 1, opt, x; i <= m; ++i) {
        opt = get();
        switch (opt) {
        case 'Q':
            printf("%lld\n", sum);
            break;
        case 'C':
            scanf("%d%lld", &x, &y);
            if (t.is_exist(x)) {
                arr[x] -= y;
                sum -= y;
            }
            break;
        case 'I':
            scanf("%d%lld", &x, &y);
            if (!t.is_exist(x)) {
                t.insert(x);
            }
            sum -= arr[x];
            arr[x] = y;
            sum += y;
            break;
        case 'D':
            scanf("%d", &x);
            x = t.get_by_rank(x);
            if (x == -1) {
                continue;
            }
            sum -= arr[x];
            arr[x] = 0;
            t.erase(x);
            break;
        }
    }
    return 0;
}