#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
#include<complex>
using namespace std;

//#define int long long
typedef long long ll;

typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 998244353;
const ll INF = mod * mod;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef pair<ll, ll> LP;
typedef vector<ll> vec;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-5;
const ld pi = acos(-1.0);

struct LiChaoTree {
	int sz;
	struct Node {
		int l, r;
		Node* chl; Node* chr;
		LP val;
		Node(int l, int r) :l(l), r(r) {
			val = { 0,INF };
			chl = chr = NULL;
		}
	};
	Node* root;
	LiChaoTree() {
		int max_n = 1e8 + 1;
		sz = 1;
		while (sz < max_n)sz <<= 1;
		root = new Node(0, sz);
	}
	ll calc(LP a, int x) {
		return a.first*x + a.second;
	}
	void add(Node* node, LP a) {
		if (!node)return;
		int l = node->l, r = node->r;
		int m = (l + r) / 2;
		//そのノードでの最小値
		if (calc(node->val, m) > calc(a, m))swap(node->val, a);
		if (r - l == 1)return;
		//左側をさらに更新しなきゃ
		if (calc(node->val, l) > calc(a, l)) {
			if (!node->chl)node->chl = new Node(l, m);
			add(node->chl, a);
		}
		else if (calc(node->val, r) > calc(a, r)) {
			if (!node->chr)node->chr = new Node(m, r);
			add(node->chr, a);
		}
	}
	void add(LP a) {
		add(root, a);
	}
	ll query(int x) {
		ll ret = INF;
		Node* node = root;
		while (node) {
			ret = min(ret, calc(node->val, x));
			int m = (node->l + node->r) / 2;
			if (x < m) {
				node = node->chl;
			}
			else {
				node = node->chr;
			}
		}
		return ret;
	}
};

void solve() {
	int n, m, q; cin >> n >> m >> q;
	vector<int> d(n);
	rep(i, n) {
		cin >> d[i];
	}
	vector<int> rd(n+1);
	rep(i, n) {
		rd[i + 1] = rd[i] + d[i];
	}
	vector<vector<int>> vl(n), vr(n);
	rep(i, m) {
		char c; int b, t;
		cin >> c >> b >> t; b--;
		if (c == 'L') {
			vl[b].push_back(t);
		}
		else {
			vr[b].push_back(t);
		}
	}
	vector<ll> ans(q);
	fill(ans.begin(), ans.end(), INF);
	vector<vector<P>>que(n);
	rep(i, q) {
		int x, y; cin >> x >>y; x--; y--;
		que[x].push_back({ y,i });

	}
	if (vr.size()) {
		LiChaoTree cr;
		rep(i, n) {
			int dist = rd[n]-rd[i];
			rep(j, vr[i].size()) {
				int  t= vr[i][j];
				cr.add({ t,(ll)t*dist });
			}
		}
		rep(i, n) {
			rep(j, vr[i].size()) {
				int t = vr[i][j];
				cr.add({ t,-(ll)t*rd[i] });
			}
			rep(j, que[i].size()) {
				int to = que[i][j].first;
				int id = que[i][j].second;
				ll x = rd[to];
				if (to < i)x += rd[n];
				//if (x < 0)x += rd[n];
				ans[id] = min(ans[id], cr.query(x));
			}
		}
	}
	if (vl.size()) {
		LiChaoTree cl;
		per(i, n) {
			int dist = rd[i];
			rep(j, vl[i].size()) {
				int t = vl[i][j];
				cl.add({ t,(ll)t*dist });
			}
		}
		per(i, n) {
			rep(j, vl[i].size()) {
				int t = vl[i][j];
				cl.add({ t,-(ll)t*(rd[n] - rd[i]) });
			}
			rep(j, que[i].size()) {
				int to = que[i][j].first;
				int id = que[i][j].second;
				ll x = rd[n]-rd[to];
				if (i < to)x += rd[n];
				//if (x < 0)x += rd[n];
				ans[id] = min(ans[id], cl.query(x));
			}
		}
	}
	rep(i, q) {
		cout << ans[i] << endl;
	}
}

signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	solve();
	//stop
	return 0;
}




Measured memory_bytes: 18820