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

struct SegmentTree {
    int n;
    vector<int> tree, lazy;
    
    SegmentTree(int size) {
        n = 1;
        while (n < size) n <<= 1;
        tree.resize(2 * n, 0);
        lazy.resize(2 * n, 0);
    }
    
    void push(int node, int l, int r) {
        if (lazy[node] == 0) return;
        tree[node] += lazy[node] * (r - l + 1);
        if (l != r) {
            lazy[2*node] += lazy[node];
            lazy[2*node+1] += lazy[node];
        }
        lazy[node] = 0;
    }
    
    void range_add(int a, int b, int val, int node, int l, int r) {
        push(node, l, r);
        if (a > r || b < l) return;
        if (a <= l && r <= b) {
            lazy[node] += val;
            push(node, l, r);
            return;
        }
        int mid = (l + r) / 2;
        range_add(a, b, val, 2*node, l, mid);
        range_add(a, b, val, 2*node+1, mid+1, r);
        tree[node] = tree[2*node] + tree[2*node+1];
    }
    
    void add(int a, int b, int val) {
        range_add(a, b, val, 1, 1, n);
    }
    
    int query_point(int x, int node, int l, int r) {
        push(node, l, r);
        if (l == r) return tree[node];
        int mid = (l + r) / 2;
        if (x <= mid) return query_point(x, 2*node, l, mid);
        else return query_point(x, 2*node+1, mid+1, r);
    }
    
    int get(int x) {
        return query_point(x, 1, 1, n);
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    int N, Q;
    cin >> N >> Q;
    vector<long long> A(N+1);  // 1-based
    for (int i = 1; i <= N; ++i) {
        cin >> A[i];
    }
    
    // Read all operations and process cnt
    vector<tuple<char, int, int>> queries(Q+1); // 1-based time
    vector<int> delta(N+2, 0);
    
    for (int t = 1; t <= Q; ++t) {
        char c;
        int x, y;
        cin >> c >> x >> y;
        queries[t] = make_tuple(c, x, y);
        if (c == 'B') {
            delta[x]++;
            delta[y+1]--;
        }
    }
    
    // Compute cnt array
    vector<int> cnt(N+1, 0);
    int current = 0;
    for (int i = 1; i <= N; ++i) {
        current += delta[i];
        cnt[i] = current;
    }
    
    // Now process A and B queries in reverse order
    vector<long long> sum_contrib(N+1, 0);
    SegmentTree st(N);
    
    for (int t = Q; t >= 1; --t) {
        char c = get<0>(queries[t]);
        int x = get<1>(queries[t]);
        int y = get<2>(queries[t]);
        if (c == 'B') {
            st.add(x, y, 1);
        } else { // 'A' case
            int num = st.get(x);
            sum_contrib[x] += (long long)y * num;
        }
    }
    
    // Compute the final B array
    for (int i = 1; i <= N; ++i) {
        long long res = A[i] * cnt[i] + sum_contrib[i];
        cout << res << (i < N ? ' ' : '\n');
    }
    
    return 0;
}