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

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, k, q;
    cin >> n >> k >> q;
    vector<long long> A(n);
    for (int i = 0; i < n; i++) cin >> A[i];

    vector<pair<int, long long>> update(k);
    for (int i = 0; i < k; i++) {
        int p;
        long long x;
        cin >> p >> x;
        update[i] = {p - 1, x};
    }

    int B_size = int(k / sqrt((double)q));
    if (B_size == 0) B_size = 1;
    int B_cnt = k / B_size + 1;

    vector<vector<tuple<int, int, int, int, int>>> query(B_cnt);
    vector<tuple<int, int, int, int, int>> etc;

    for (int i = 0; i < q; i++) {
        int l, r, d, u;
        cin >> l >> r >> d >> u;
        l--; d--;
        if (r - l <= B_size) {
            etc.emplace_back(l, r, d, u, i);
        } else {
            query[l / B_size].emplace_back(l, r, d, u, i);
        }
    }

    int C_size = int(sqrt((double)n));
    int C_cnt = n / C_size + 1;
    vector<long long> B(C_cnt, 0);
    for (int i = 0; i < n; i++) B[i / C_size] += A[i];

    vector<long long> Ans(q);

    auto compute_sum = [&](int d, int u, const vector<long long>& A, const vector<long long>& B) {
        long long rep = 0;
        int now = d;
        while (now < u) {
            if (now % C_size == 0 && now + C_size <= u) {
                rep += B[now / C_size];
                now += C_size;
            } else {
                rep += A[now];
                now++;
            }
        }
        return rep;
    };

    // --- process small queries (etc)
    for (auto [l, r, d, u, idx] : etc) {
        vector<tuple<int, long long, int, long long>> S;
        for (int j = l; j < r; j++) {
            auto [p, x] = update[j];
            if (A[p] < x && d <= p && p < u) {
                S.emplace_back(p, A[p], p / C_size, B[p / C_size]);
                B[p / C_size] += x - A[p];
                A[p] = x;
            }
        }
        long long rep = compute_sum(d, u, A, B);
        for (int j = (int)S.size() - 1; j >= 0; j--) {
            auto [p, x, p_, x_] = S[j];
            A[p] = x;
            B[p_] = x_;
        }
        Ans[idx] = rep;
    }

    vector<long long> A_ = A;
    vector<long long> B_ = B;

    // --- process large queries
    for (int i = 0; i < B_cnt; i++) {
        if (query[i].empty()) continue;

        A = A_;
        B = B_;

        sort(query[i].begin(), query[i].end(),
             [](auto& a, auto& b) {
                 return get<1>(a) < get<1>(b);
             });

        int l = B_size * (i + 1);
        int r = l;

        for (auto [nl, nr, d, u, idx] : query[i]) {
            for (int j = r; j < nr; j++) {
                auto [p, x] = update[j];
                if (A[p] < x) {
                    B[p / C_size] += x - A[p];
                    A[p] = x;
                }
            }
            r = nr;

            vector<tuple<int, long long, int, long long>> S;
            for (int j = nl; j < l; j++) {
                auto [p, x] = update[j];
                if (A[p] < x && d <= p && p < u) {
                    S.emplace_back(p, A[p], p / C_size, B[p / C_size]);
                    B[p / C_size] += x - A[p];
                    A[p] = x;
                }
            }

            long long rep = compute_sum(d, u, A, B);
            for (int j = (int)S.size() - 1; j >= 0; j--) {
                auto [p, x, p_, x_] = S[j];
                A[p] = x;
                B[p_] = x_;
            }
            Ans[idx] = rep;
        }
    }

    for (auto v : Ans) cout << v << "\n";
    return 0;
}