#pragma GCC optimize("Ofast", "unroll-loops")

#include <bits/stdc++.h>

using namespace std;

#define ll long long

struct LazySegmentTree {
private:
	int n; // length of node, lazy
	vector<ll> node, lazy;
	/* propagete the laziness of the k-th node. */
	void eval(int k, int l, int r) {
		if (lazy[k] != 0) {
			node[k] += lazy[k];
			if (r - l > 1) {
				lazy[2 * k + 1] += lazy[k] / 2;
				lazy[2 * k + 2] += lazy[k] / 2;
			}
			lazy[k] = 0;
		}
	}
public:
	/* constructor. v is the data. */
	LazySegmentTree(vector<ll> v) {
		int sz = (int)v.size();
		n = 1; while (n < sz) n *= 2;
		node.resize(2 * n - 1);
		lazy.resize(2 * n - 1, 0);

		for (int i = 0; i < sz; i++) node[i + n - 1] = v[i];
		for (int i = n - 2; i >= 0; i--) node[i] = node[i * 2 + 1] + node[i * 2 + 2];
	}
	/* add x to s[a],s[a+1],...,s[b-1] */
	void add(int a, int b, ll x, int k = 0, int l = 0, int r = -1) {
		if (r < 0) r = n;
		eval(k, l, r);
		if (b <= l || r <= a) return;
		if (a <= l && r <= b) {
			lazy[k] += (r - l) * x;
			eval(k, l, r);
		}
		else {
			add(a, b, x, 2 * k + 1, l, (l + r) / 2);
			add(a, b, x, 2 * k + 2, (l + r) / 2, r);
			node[k] = node[2 * k + 1] + node[2 * k + 2];
		}
	}
	/* calculate the sum of s[a],s[a+1],...,s[b-1] */
	ll getsum(int a, int b, int k = 0, int l = 0, int r = -1) {
		if (r < 0) r = n;
		eval(k, l, r);
		if (b <= l || r <= a) return 0;
		if (a <= l && r <= b) return node[k];
		ll vl = getsum(a, b, 2 * k + 1, l, (l + r) / 2);
		ll vr = getsum(a, b, 2 * k + 2, (l + r) / 2, r);
		return vl + vr;
	}
};

struct Query {
	char c; int x, y;
};

int main() {
	int N, Q; cin >> N >> Q;
	vector<int> A(N);
	for (int i = 0; i < N; ++i)
		cin >> A[i];
	vector<Query> q(Q);
	for (int i = Q - 1; i >= 0; --i)
		cin >> q[i].c >> q[i].x >> q[i].y;
	LazySegmentTree seg(vector<ll>(N, 0LL));
	vector<ll> res(N, 0LL);
	for (int i = 0; i < Q; ++i) {
		if (q[i].c == 'A') {
			ll cnt = seg.getsum(q[i].x - 1, q[i].x);
			res[q[i].x - 1] += q[i].y * cnt;
		}
		else {
			seg.add(q[i].x - 1, q[i].y, 1LL);
		}
	}
	for (int i = 0; i < N; ++i)
		res[i] += seg.getsum(i, i + 1) * A[i];
	for (int i = 0; i < N - 1; ++i)
		cout << res[i] << " ";
	cout << res[N - 1] << endl;
	return 0;
}