// う？笑
#include <bits/stdc++.h>

using namespace std;

using int64 = long long;
const int mod = 1e9 + 7;

const int64 infll = (1LL << 62) - 1;
const int inf = (1 << 30) - 1;

struct IoSetup {
  IoSetup() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(10);
    cerr << fixed << setprecision(10);
  }
} iosetup;


template< typename T1, typename T2 >
ostream &operator<<(ostream &os, const pair< T1, T2 > &p) {
  os << p.first << " " << p.second;
  return os;
}

template< typename T1, typename T2 >
istream &operator>>(istream &is, pair< T1, T2 > &p) {
  is >> p.first >> p.second;
  return is;
}

template< typename T >
ostream &operator<<(ostream &os, const vector< T > &v) {
  for(int i = 0; i < (int) v.size(); i++) {
    os << v[i] << (i + 1 != v.size() ? " " : "");
  }
  return os;
}

template< typename T >
istream &operator>>(istream &is, vector< T > &v) {
  for(T &in : v) is >> in;
  return is;
}

template< typename T1, typename T2 >
inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }

template< typename T1, typename T2 >
inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }

template< typename T = int64 >
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 V >
typename enable_if< is_class< T >::value == 0 >::type fill_v(T &t, const V &v) {
  t = v;
}

template< typename T, typename V >
typename enable_if< is_class< T >::value != 0 >::type fill_v(T &t, const V &v) {
  for(auto &e : t) fill_v(e, v);
}

template< typename F >
struct FixPoint : F {
  FixPoint(F &&f) : F(forward< F >(f)) {}

  template< typename... Args >
  decltype(auto) operator()(Args &&... args) const {
    return F::operator()(*this, forward< Args >(args)...);
  }
};

template< typename F >
inline decltype(auto) MFP(F &&f) {
  return FixPoint< F >{forward< F >(f)};
}

template< typename T >
struct LiChaoTree {
  struct Line {
    T a, b;

    Line(T a, T b) : a(a), b(b) {}

    inline T get(T x) const { return a * x + b; }

    inline bool over(const Line &b, const T &x) const {
      return get(x) < b.get(x);
    }
  };

  vector< T > xs;
  vector< Line > seg;
  int sz;

  LiChaoTree(const vector< T > &x, T INF) : xs(x) {
    sz = 1;
    while(sz < xs.size()) sz <<= 1;
    while(xs.size() < sz) xs.push_back(xs.back() + 1);
    seg.assign(2 * sz - 1, Line(0, INF));
  }

  void update(Line &x, int k, int l, int r) {
    int mid = (l + r) >> 1;
    auto latte = x.over(seg[k], xs[l]), malta = x.over(seg[k], xs[mid]);
    if(malta) swap(seg[k], x);
    if(l + 1 >= r) return;
    else if(latte != malta) update(x, 2 * k + 1, l, mid);
    else update(x, 2 * k + 2, mid, r);
  }

  void update(T a, T b) { // ax+b
    Line l(a, b);
    update(l, 0, 0, sz);
  }

  T query(int k) { // xs[k]
    const T x = xs[k];
    k += sz - 1;
    T ret = seg[k].get(x);
    while(k > 0) {
      k = (k - 1) >> 1;
      ret = min(ret, seg[k].get(x));
    }
    return ret;
  }
};


int main() {
  int N, M, Q;
  cin >> N >> M >> Q;
  vector< int64 > DD(N);
  cin >> DD;

  vector< char > C(M);
  vector< int64 > B(M), T(M);
  for(int i = 0; i < M; i++) {
    cin >> C[i] >> B[i] >> T[i];
    --B[i];
  }
  vector< int64 > X(Q), Y(Q);
  for(int i = 0; i < Q; i++) {
    cin >> X[i] >> Y[i];
    --X[i], --Y[i];
  }

  vector< int64 > ans(Q, infll);

  auto solve = [&]() {

    vector< pair< int64, int64 > > latte, malta;

    for(int i = 0; i < M; i++) {
      if(C[i] == 'R') latte.emplace_back(B[i], T[i]);
      else malta.emplace_back(B[i], T[i]);
    }
    vector< int64 > D(N + 1);
    for(int i = 1; i <= N; i++) D[i] = DD[i - 1];
    for(int i = 1; i <= N; i++) D[i] += D[i - 1];


    vector< int64 > uku_chan[4];
    vector< int > ord;
    for(int i = 0; i < Q; i++) {
      if(X[i] < Y[i]) {
        ord.emplace_back(i);
        uku_chan[0].emplace_back(D[Y[i]]);
        uku_chan[1].emplace_back(D[Y[i]] + D[N]);
        uku_chan[2].emplace_back(-D[Y[i]] + D[N]);
        uku_chan[3].emplace_back(-D[Y[i]] + 2 * D[N]);
      }
    }
    if(ord.empty()) return;

    for(int i = 0; i < 4; i++) {
      sort(begin(uku_chan[i]), end(uku_chan[i]));
      uku_chan[i].erase(unique(begin(uku_chan[i]), end(uku_chan[i])), end(uku_chan[i]));
    }

    using CHT = LiChaoTree< int64 >;

    sort(begin(latte), end(latte), [&](auto p, auto q) {
      return p.first < q.first;
    });
    sort(begin(malta), end(malta), [&](auto p, auto q) {
      return p.first < q.first;
    });

    // ソートをします　つまらねえ
    // ああ　うく
    sort(begin(ord), end(ord), [&](int a, int b) {
      return X[a] < X[b];
    });

    {
      CHT cht(uku_chan[0], infll);
      int ptr = 0;
      for(int i : ord) {
        int x = X[i];
        int y = Y[i];
        while(ptr < latte.size() && latte[ptr].first <= x) {
          auto &p = latte[ptr];
          cht.update(p.second, -p.second * D[p.first]);
          ++ptr;
        }
        y = lower_bound(begin(uku_chan[0]), end(uku_chan[0]), D[y]) - begin(uku_chan[0]);
        chmin(ans[i], cht.query(y));
      }
    }

    {
      CHT cht(uku_chan[1], infll);

      int ptr = (int) latte.size() - 1;
      for(int p = (int) ord.size() - 1; p >= 0; p--) {
        int i = ord[p];
        int x = X[i];
        int y = Y[i];
        while(ptr >= 0 && latte[ptr].first > x) {
          auto &p = latte[ptr];
          cht.update(p.second, -p.second * D[p.first]);
          --ptr;
        }
        y = lower_bound(begin(uku_chan[1]), end(uku_chan[1]), D[y] + D[N]) - begin(uku_chan[1]);
        chmin(ans[i], cht.query(y));
      }
    }


    {
      CHT cht(uku_chan[2], infll);
      int ptr = (int) malta.size() - 1;
      for(int p = (int) ord.size() - 1; p >= 0; p--) {
        int i = ord[p];
        int x = X[i];
        int y = Y[i];
        while(ptr >= 0 && malta[ptr].first >= x) {
          auto &p = malta[ptr];
          cht.update(p.second, p.second * D[p.first]);
          --ptr;
        }
        y = lower_bound(begin(uku_chan[2]), end(uku_chan[2]), -D[y] + D[N]) - begin(uku_chan[2]);
        chmin(ans[i], cht.query(y));
      }
    }

    {
      CHT cht(uku_chan[3], infll);
      int ptr = 0;
      for(int i : ord) {
        int x = X[i];
        int y = Y[i];
        while(ptr < malta.size() && malta[ptr].first < x) {
          auto &p = malta[ptr];
          cht.update(p.second, p.second * D[p.first]);
          ++ptr;
        }
        y = lower_bound(begin(uku_chan[3]), end(uku_chan[3]), 2 * D[N] - D[y]) - begin(uku_chan[3]);
        chmin(ans[i], cht.query(y));
      }
    }

    /*
    for(int i = 0; i < Q; i++) {
      int x = X[i];
      int y = Y[i];
      if(x < y) {
        int64 ret = infll;
        /*
        for(auto &p : latte) {
          if(p.first <= x) ret = min(ret, p.second * (D[y] - D[p.first]));
          else ret = min(ret, p.second * ((D[N] - D[p.first]) + D[y]));
        }
        for(auto &p : malta) {
          if(x <= p.first) ret = min(ret, p.second * (D[p.first] + (D[N] - D[y])));
          else ret = min(ret, p.second * (D[p.first] + D[N] + (D[N] - D[y])));
        }



        /*for(auto &p : latte) {
          if(p.first <= x) ret = min(ret, (p.second * D[y]) - p.second * D[p.first]);
          else ret = min(ret, (p.second * (D[y] + D[N])) - p.second * D[p.first]);
        }
        for(auto &p : malta) {
          if(x <= p.first) ret = min(ret, p.second * D[p.first] + (p.second * (D[N] - D[y])));
          else ret = min(ret, p.second * D[p.first] + (p.second * (2 * D[N] - D[y])));
        }

        chmin(ret, latte_seg.query(0, x + 1, D[y]));
        chmin(ret, latte_seg.query(x + 1, N, D[y] + D[N]));
        chmin(ret, malta_seg.query(x, N, D[N] - D[y]));
        chmin(ret, malta_seg.query(0, x, 2 * D[N] - D[y]));


        ans[i] = ret;
      }
    }
    */
  };


  solve();

  for(int i = 0; i < M; i++) {
    C[i] = (C[i] == 'R' ? 'L' : 'R');
    B[i] = N - B[i] - 1;
  }
  for(int i = 0; i < Q; i++) {
    X[i] = N - X[i] - 1;
    Y[i] = N - Y[i] - 1;
  }
  vector< int64 > EE;
  for(int i = 0; i < N; i++) EE.emplace_back(DD[(N + N + N + N - i - 2) % N]);
  EE.swap(DD);
  solve();
  for(auto &p : ans) cout << p << endl;
}






Measured memory_bytes: 16780