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

struct Fenwick {
    int n = 0;
    vector<int> t;
    Fenwick() {}
    Fenwick(int n_) { init(n_); }
    void init(int n_) { n = n_; t.assign(n + 1, 0); }
    void add(int idx, int delta) {
        for (int i = idx + 1; i <= n; i += i & -i) t[i] += delta;
    }
    int sumPrefix(int idx) const {
        int res = 0;
        for (int i = idx + 1; i > 0; i -= i & -i) res += t[i];
        return res;
    }
};

struct Op {
    bool isGet;
    int a, b, x, y, k, l;
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N, M;
    if (!(cin >> N >> M)) return 0;
    vector<int> A(N + 1);
    for (int i = 1; i <= N; ++i) cin >> A[i];

    vector<Op> ops;
    ops.reserve(M);
    vector<pair<int,int>> allPairs;
    allPairs.reserve(N + M);
    for (int i = 1; i <= N; ++i) allPairs.emplace_back(i, A[i]);

    for (int i = 0; i < M; ++i) {
        string s; cin >> s;
        if (s == "SET") {
            int a, b; cin >> a >> b;
            ops.push_back({false, a, b, 0, 0, 0, 0});
            allPairs.emplace_back(a, b);
        } else {
            int x, y, k, l; cin >> x >> y >> k >> l;
            ops.push_back({true, 0, 0, x, y, k, l});
        }
    }
    vector<vector<int>> nodes(N + 1);
    for (auto [pos, val] : allPairs) {
        for (int i = val; i <= N; i += i & -i) nodes[i].push_back(pos);
    }
    for (int i = 1; i <= N; ++i) {
        auto &v = nodes[i];
        sort(v.begin(), v.end());
        v.erase(unique(v.begin(), v.end()), v.end());
    }
    vector<Fenwick> bits(N + 1);
    for (int i = 1; i <= N; ++i) bits[i].init((int)nodes[i].size());

    vector<int> cur = A;

    auto addPoint = [&](int pos, int val, int delta) {
        for (int i = val; i <= N; i += i & -i) {
            auto &v = nodes[i];
            int idx = int(lower_bound(v.begin(), v.end(), pos) - v.begin());
            bits[i].add(idx, delta);
        }
    };

    for (int pos = 1; pos <= N; ++pos) addPoint(pos, cur[pos], +1);

    auto countLE_posLE = [&](int vmax, int posLimit) -> long long {
        if (vmax <= 0 || posLimit <= 0) return 0;
        long long res = 0;
        for (int i = vmax; i > 0; i -= i & -i) {
            const auto &v = nodes[i];
            if (v.empty()) continue;
            int idx = int(upper_bound(v.begin(), v.end(), posLimit) - v.begin()) - 1;
            if (idx >= 0) res += bits[i].sumPrefix(idx);
        }
        return res;
    };

    auto rectQuery = [&](int x, int y, int k, int l) -> long long {
        if (x > y || k > l) return 0;
        long long Ayy = countLE_posLE(l, y);
        long long Ayx = countLE_posLE(l, x - 1);
        long long B yy = countLE_posLE(k - 1, y);
        long long B yx = countLE_posLE(k - 1, x - 1);
        return (Ayy - Ayx) - (B yy - B yx);
    };
    ostringstream out;
    for (const auto &q : ops) {
        if (!q.isGet) {
            int pos = q.a, val = q.b;
            if (cur[pos] != val) {
                addPoint(pos, cur[pos], -1);
                addPoint(pos, val, +1);
                cur[pos] = val;
            }
        } else {
            long long ans = rectQuery(q.x, q.y, q.k, q.l);
            out << ans << '\n';
        }
    }
    cout << out.str();
    return 0;
}