#include <bits/stdc++.h>

typedef long long ll;
typedef unsigned long long ull;
#define FOR(i, a, b) for (int i = a; i <= b; ++i)
#define ROF(i, a, b) for (int i = a; i >= b; --i)

inline ll Max(const ll &a, const ll &b) { return a > b ? a : b; }
inline bool chkmax(ll &a, const ll &b) { return a < b ? a = b, true : false; }

inline int read() {
    int f = 1, x = 0;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-') f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    return x * f;
}

const int N = 5e4 + 7;
const int Q = 1e6 + 7;
const ll INF = (ll)5e13 + 1;
using namespace std;

ll infcnt;
int n, m, q;

struct sgt {
#define ls(x) (x << 1)
#define rs(x) (x << 1 | 1)
    ll mx[N * 4], hmx[N * 4], tag[N * 4], htag[N * 4];
    void pushup(int x) {
        mx[x] = Max(mx[ls(x)], mx[rs(x)]);
        chkmax(hmx[x], mx[x]);
    }
    void pushtag(int x, ll ad, ll had) {  //
        chkmax(hmx[x], mx[x] + had);
        chkmax(htag[x], tag[x] + had);
        mx[x] += ad, tag[x] += ad;
    }
    void pushdown(int x) {
        if (!tag[x] && !htag[x]) return;
        pushtag(ls(x), tag[x], htag[x]), pushtag(rs(x), tag[x], htag[x]);
        tag[x] = htag[x] = 0;
    }
    void change(int x, int l, int r, int ql, int qr, ll w) {
        if (ql <= l && r <= qr) return pushtag(x, w, w);
        int mid = (l + r) >> 1;
        pushdown(x);
        if (ql <= mid) change(ls(x), l, mid, ql, qr, w);
        if (mid + 1 <= qr) change(rs(x), mid + 1, r, ql, qr, w);
        pushup(x);
    }
    ll query(int x, int l, int r, int ql, int qr) {
        if (ql <= l && r <= qr) return hmx[x];
        int mid = (l + r) >> 1;
        ll res = 0;
        pushdown(x);
        if (ql <= mid) chkmax(res, query(ls(x), l, mid, ql, qr));
        if (mid + 1 <= qr) chkmax(res, query(rs(x), mid + 1, r, ql, qr));
        return res;
    }
    void clear() {
        change(1, 1, n, 1, n, INF);
        ++infcnt;
    }
} tr;

#define pb push_back

int xl[Q], xr[Q], yl[Q], yr[Q];
struct jgt {
    int l, r;
    ll w;
    bool operator<(const jgt &a) const { return w < a.w; }
};
vector<jgt> cg[N];
int idq[Q];
ll res[Q];
bool cmpr(const int &a, const int &b) { return xr[a] < xr[b]; }
bool cmpl(const int &a, const int &b) { return xl[a] > xl[b]; }
void solve(int l, int r, int L, int R) {
    if (l > r || L > R) return;
    int mid = (l + r) >> 1;
    vector<int> lr, _l, _r;
    // puts("");
    // printf(" %d %d %d %d\n", l, r, L, R);
    FOR(i, L, R) {
        int I = idq[i];
        if (l == r || (xl[I] <= mid && mid + 1 <= xr[I])) {
            lr.pb(I);
            // printf("%d ", I);
        } else if (xr[I] <= mid) {
            _l.pb(I);
        } else {
            _r.pb(I);
        }
    }
    // puts("\n");
    int szl = (int)_l.size(), szr = (int)_r.size();
    FOR(i, 0, szl - 1) { idq[L + i] = _l[i]; }
    FOR(i, 0, szr - 1) { idq[L + szl + i] = _r[i]; }
    if (l < r) {
        solve(l, mid, L, L + szl - 1);
    }
    FOR(k, l, mid) {
        for (jgt tmp : cg[k]) {
            // printf(" add %d %d %d\n", tmp.l, tmp.r, tmp.w);
            tr.change(1, 1, n, tmp.l, tmp.r, tmp.w);
        }
    }
    // puts("-");
    tr.clear();
    if (mid < r) {
        solve(mid + 1, r, L + szl, L + szl + szr - 1);
    }
    tr.clear();
    sort(lr.begin(), lr.end(), cmpr);
    int p = mid + 1;
    for (int nw : lr) {
        while (p <= xr[nw]) {
            for (jgt tmp : cg[p]) {
                // printf(" add %d %d %d\n", tmp.l, tmp.r, tmp.w);
                tr.change(1, 1, n, tmp.l, tmp.r, tmp.w);
            }
            ++p;
        }
        chkmax(res[nw], tr.query(1, 1, n, yl[nw], yr[nw]) - infcnt * INF);
    }
    // puts("-");
    ROF(k, p - 1, mid + 1) {
        for (jgt tmp : cg[k]) {
            // printf(" add %d %d %d\n", tmp.l, tmp.r, -tmp.w);
            tr.change(1, 1, n, tmp.l, tmp.r, -tmp.w);
        }
    }
    // puts("-");
    tr.clear();
    sort(lr.begin(), lr.end(), cmpl);
    p = mid;
    for (int nw : lr) {
        while (p > xl[nw]) {
            int kel = (int)cg[p].size();
            jgt tmp;
            ROF(i, kel - 1, 0) {  // 这里先负后正
                tmp = cg[p][i];
                // printf(" add %d %d %d\n", tmp.l, tmp.r, -tmp.w);
                tr.change(1, 1, n, tmp.l, tmp.r, -tmp.w);
            }
            --p;
        }
        chkmax(res[nw], tr.query(1, 1, n, yl[nw], yr[nw]) - infcnt * INF);
    }
    // puts("-");
    ROF(k, p, l) {
        for (jgt tmp : cg[k]) {
            // printf(" add %d %d %d\n", tmp.l, tmp.r, -tmp.w);
            tr.change(1, 1, n, tmp.l, tmp.r, -tmp.w);
        }
    }
    // printf("pos %d %d\n", l, r);
    // puts("---");
}

int main() {
    // freopen("C.in", "r", stdin);
    // freopen("C.out", "w", stdout);
    n = read(), m = read(), q = read();
    FOR(i, 1, m) {
        int x = read(), y = read(), xx = read(), yy = read(), w = read();
        cg[x].push_back({y, yy, w});
        cg[xx + 1].push_back({y, yy, -w});
    }
    FOR(i, 1, n) { sort(cg[i].begin(), cg[i].end()); }
    FOR(i, 1, q) { xl[i] = read(), yl[i] = read(), xr[i] = read(), yr[i] = read(), idq[i] = i; }
    solve(1, n, 1, q);
    FOR(i, 1, q) { printf("%lld\n", res[i]); }
    return 0;
}