#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cstdint>
using namespace std;
typedef long long ll;
#define MP make_pair
#define PB push_back
#define inf (ll)1000000000007
#define mod 1000000007
#define rep(i,n) for(int i = 0; i < (int)(n); ++i)
#define int long long
// 単調でない傾きについての convex hull trick
// Li Chao Segment Tree を用いて O(nlog(MAX_A))
template<typename T> class CHT {
private:
    struct node {
        node *left, *right;
        T a, b;
        node() : left(nullptr), right(nullptr) {}
        node(T arg1, T arg2)
            : left(nullptr), right(nullptr), a(arg1), b(arg2) {}
        T f(T x, T a, T b) {
            return a * x + b;
        }
        void add(T l, T r, T a_, T b_) {
            if(f(l,a_,b_) < f(l,a,b)) {
                swap(a,a_), swap(b,b_);
            }
            if(f(r,a,b) <= f(r,a_,b_)) return;
            T mid = (l + r) / 2;
            if(f(mid,a,b) < f(mid,a_,b_)){
                if(!right){
                    right = new node(a_,b_);
                }else{
                    right->add(mid+1,r,a_,b_);
                }
            }else{
                swap(a, a_), swap(b, b_);
                if(!left){
                    left = new node(a_,b_);
                }else{
                    left->add(l,mid,a_,b_);
                }
            }
        }
        T query(T l, T r, T k) {
            if(l == r) return f(k, a, b);
            T ans = f(k, a, b);
            T mid = (l + r) / 2;
            if(k <= mid && left){
                ans = min(ans, left->query(l, mid, k));
            }
            if(k > mid && right){
                ans = min(ans, right->query(mid+1, r, k));
            }
            return ans;
        }
        void rm() {
            if(left) left->rm();
            if(right) right->rm();
            delete this;
        }
    };
    node *root;
    T min_val, max_val;
public:
    // arg1:クエリになげる最小の値, arg2:クエリになげる最大の値
    CHT(T arg1, T arg2)
        : min_val(arg1), max_val(arg2) { root = new node(0,numeric_limits<T>::max()/10); }
    // f(x) = a*x+b を挿入
    void add(T a, T b) {
        return root->add(min_val, max_val, a, b);
    }
    // x=kでの最小値
    T query(T k) {
        return root->query(min_val, max_val, k);
    }
    ~CHT(){
        root->rm();
    }
};

int res[300000];
vector<pair<pair<int,int>,int> > query;
int n,m,q;
    
void solve(vector<int>&R,vector<int>&dist){
    CHT<ll> cht(-inf,inf);
    
    rep(i,n){
        if(i==0)continue;
    
        if(R[i]!=inf){
            //cerr << R[i] << " " <<  R[i]*(dist[n]-dist[i]) << endl; 
            cht.add(R[i],R[i]*(dist[n]-dist[i]));
        }
    }
    int tm = 0;
    sort(query.begin(),query.end());
    int K = 0;
    rep(i,n){
        //cerr<< R[i] << " " << tm << endl;
        if(R[i]!=inf){
            cht.add(R[i],-R[i]*tm);
        }
        while(K!=q&&query[K].first.first == i){
            int from = query[K].first.first;
            int to = query[K].first.second;
            int query_id = query[K].second;
            int d;  
            if(to>from){
                d = dist[to]-dist[from];
            }else{
                d = dist[n] - dist[from] +dist[to];
            }
            //cerr << "d: "<< d << " tm " << tm << endl;
            int ans = cht.query(d+tm);
            //cerr << ans.first << " " << ans.second << endl;
            res[query_id] = min(res[query_id],ans);
            K++;
        }
        tm += dist[i+1]-dist[i];
    }   
    
}


signed main(){
    cin >> n >> m >> q;
    rep(i,q){
        res[i] = inf;
    }
    vector<int> dist(n+1);
    dist[0] = 0;
    rep(i,n){
        int k;
        cin >> k;
        dist[i+1]= dist[i]+k;
    } 
    vector<int> L(n+1,inf),R(n+1,inf);
    rep(i,m){
        char c;
        int b;
        int t;
        cin >> c >> b >> t;
        b--;
        if(c=='R'){
            R[b] = min(t,R[b]);
        }else{
            L[b] = min(t,L[b]);
        }
    }
    rep(i,q){
        int a,b;
        cin >> a >> b;
        a--;b--;
        query.push_back(MP(MP(a,b),i));
    }
    int cnt = 0;
    rep(i,n){
        if(R[i]!=inf)cnt++;
    }
    if(cnt!=0)solve(R,dist);
    // rep(i,q){
    //     cout << res[i] << endl;
    // }
    rep(i,q){
        int a = query[i].first.first;
        int b = query[i].first.second;
        if(a!=0){
            a = n-a;
        }
        if(b!=0){
            b = n-b;
        }
        query[i].first.first = a;
        query[i].first.second = b;
    }
    vector<int> L2(n);
    vector<int> dist2(n+1);
    rep(i,n){
        if(i==0){
            L2[i] = L[i];
        }else{
            L2[i] = L[n-i];
        }
    }
    rep(i,n){
        dist2[i] = dist[n] - dist[n-i];
    }
    dist2[n] = dist[n];
    // rep(i,n){
    //     cerr << dist2[i] << " ";
    // }
    // cerr << endl;
    
    int cnt2 = 0;
    rep(i,n){
        if(L[i]!=inf)cnt2++;
    }
    if(cnt2!=0)solve(L2,dist2);
    rep(i,q){
        cout << res[i] << endl;
    }
    return 0;
}


Measured memory_bytes: 15236