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

#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for(int64 i = 0;i < (n);i++)
#define FOR(i, a, b) for(int64 i = (a);i < (b);i++)
#define all(x) x.begin(),x.end()
#define fs first
#define sc second

using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;

const double eps = 1e-10;

template<typename A, typename B>inline void chmin(A &a, B b){if(a > b) a = b;}
template<typename A, typename B>inline void chmax(A &a, B b){if(a < b) a = b;}

template<typename T>
vector<T> make_v(size_t a){return vector<T>(a);}

template<typename T,typename... Ts>
auto make_v(size_t a,Ts... ts){
  return vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));
}

template<typename T,typename U,typename... V>
typename enable_if<is_same<T, U>::value!=0>::type
fill_v(U &u,const V... v){u=U(v...);}

template<typename T,typename U,typename... V>
typename enable_if<is_same<T, U>::value==0>::type
fill_v(U &u,const V... v){
  for(auto &e:u) fill_v<T>(e,v...);
}
template<typename T = ::std::int64_t, class Compare = ::std::less<T>>
class LiChaoTree{
private:
    static Compare comp;
    using size_type = ::std::size_t;

    struct Line{
        T a, b;
        bool used;
        Line() : a(0), b(0), used(false) {}
        Line(const T &a_, const T &b_) : a(a_), b(b_), used(true) {}
        T operator()(const T &x) { return a*x+b; }
    };

    size_type n, cnt;
    ::std::vector<Line> node;
    ::std::vector<T> pos;

    void add(size_type l, size_type r, const Line &line){
        cnt++;
        size_type l0 = l, r0 = r;
        size_type sz = 1;
        for (l += n, r += n; l < r; l >>= 1, r >>= 1, sz <<= 1) {
            if (l & 1) add(l, l0, l0+sz, line), l0 += sz, l++;
            if (r & 1) --r, r0 -= sz, add(r, r0, r0+sz, line);
        }
    }

    void add(size_type k, size_type l, size_type r, Line line){
        if (!node[k].used) {
            node[k] = line;
            return;
        }
        T ly = line(pos[l]), ry = line(pos[r-1]);
        T nly = node[k](pos[l]), nry = node[k](pos[r-1]);
        if (comp(nly, ly) && comp(nry, ry)) return;
        if (comp(ly, nly) && comp(ry, nry)) {
            node[k] = line;
            return;
        }
        if (r - l == 1) return;
        size_type m = (l + r) >> 1;
        if (comp(nly, ly)) swap(node[k], line);
        if (comp(line(pos[m]), node[k](pos[m]))) {
            swap(node[k], line);
            add((k << 1) | 1, m, r, line);
        } else {
            add(k << 1, l, m, line);
        }
    }
public:
    LiChaoTree(){}
    LiChaoTree(const ::std::vector<T> &v) : pos(v), cnt(0) {
        n = 1;
        while (n < pos.size()) n <<= 1;
        sort(pos.begin(), pos.end());
        pos.erase(unique(pos.begin(), pos.end()), pos.end());
        pos.resize(n, pos.back());
        node.resize(n << 1);
    }

    void add(T a, T b){
        add(0, n, Line(a, b));
    }

    void add(T a, T b, T lx, T rx){
        size_type l = lower_bound(pos.begin(), pos.end(), lx) - pos.begin();
        size_type r = lower_bound(pos.begin(), pos.end(), rx) - pos.begin();
        add(l, r, Line(a, b));
    }

    ::std::pair<bool, T> query(T x) {
        Line l = get(x);
        return ::std::make_pair(l.used, l(x));
    }

    Line get(T x){
        size_type i = lower_bound(pos.begin(), pos.end(), x) - pos.begin() + n;
        size_type res = -1;
        for(; i > 0; i >>= 1){
            if (node[i].used)
                if (res == -1 || comp(node[i](x), node[res](x))) res = i;
        }
        return res == -1 ? Line() : node[res];
    }

    size_type size() { return cnt; } // the number of lines
};

template<class T, class Compare>
Compare LiChaoTree<T, Compare>::comp;

int main(void){
	cin.tie(0);
	ios::sync_with_stdio(false);
    using T = tuple<int64, int64, int64>; // -1 -> add, other -> query id

	int64 N, M, Q;
	cin >> N >> M >> Q;
	vector<int64> d(N), d3(3*N+1, 0);
	vector<PLL> bus[2], q(Q);
	REP(i, N) {
	    cin >> d[i];
	}
	REP(i, 3*N) d3[i+1] += d3[i];
    vector<vector<PLL>> ev(N);
	REP(i, M) {
	    char c;
	    int64 b, t;
	    cin >> c >> b >> t;
	    bus[c == 'L'].emplace_back(b, t);
	}
	REP(i, Q) {
	    cin >> q[i].fs >> q[i].sc;
	}
	vector<int64> res(Q, INF_LL);

	REP(dir, 2) {
	    ev = vector<vector<PLL>>(3*N);
	    d3 = vector<int64>(3*N+1, 0);
	    REP(i, N) d3[i+1] = d3[i+N+1] = d3[i+2*N+1] = d[i];
	    REP(i, 3*N) d3[i+1] += d3[i];
	    REP(i, bus[dir].size()) {
	        int64 b, t;
	        tie(b, t) = bus[dir][i]; b--;
	        if (dir == 1) b = (N-b)%N;
	        ev[b].push_back(PLL(-1, t));
            ev[b+N].push_back(PLL(-1, t));
            ev[b+2*N].push_back(PLL(-1, t));
	    }
	    REP(i, Q) {
	        int64 x, y;
	        tie(x, y) = q[i]; x--; y--;
	        if (dir == 1) { x = (N-x)%N; y = (N-y)%N; }
	        if (y >= x) {
	            ev[x].emplace_back(i, y);
	            x += N; y += N;
	        } else {
	            y += N;
	        }
//	        cout << i << ": " << x << "->" << y << endl;
	        ev[x].emplace_back(i, y);
	        ev[x+N].emplace_back(i, y+N);
	    }

	    LiChaoTree<> lct(d3);

        REP(i, 3*N) {
            sort(all(ev[i]));
            REP(j, ev[i].size()) {
                if (ev[i][j].fs == -1) {
//                    cout << i << " " << ev[i][j].sc << " " << -d3[i] * ev[i][j].sc << endl;
                    lct.add(ev[i][j].sc, -d3[i]*ev[i][j].sc);
                } else {
                    auto ret = lct.query(d3[ev[i][j].sc]);
//                    cout << i << " " << ev[i][j].fs << " " << ev[i][j].sc << ": " << ret.fs << " " << ret.sc << endl;
                    if (ret.fs) {
                        chmin(res[ev[i][j].fs], ret.sc);
                    }
                }
            }
        }

	    reverse(all(d));
	}
	REP(i, res.size()) {
	    cout << res[i] << endl;
	}
}



Measured memory_bytes: 62224