/*
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("avx2,fma,bmi,bmi2,sse4.2,popcnt,lzcnt")
*/

#include <bits/stdc++.h>
#define taskname ""
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define int long long
#define i64 long long
#define pb push_back
#define ff first
#define ss second
#define isz(x) (int)x.size()
using namespace std;

const int mxN = 2.5e5 + 5;
const int mod = 1e9 + 7;
const i64 oo = 1e18;

struct Rectangle {
    int x1, y1, x2, y2;

    friend istream & operator >> (istream &in, Rectangle &r) {
        return in >> r.x1 >> r.y1 >> r.x2 >> r.y2;
    }

    void apply(int dx, int dy) {
        x1 += dx, x2 += dx;
        y1 += dy, y2 += dy;
    }
} a[mxN];

struct Op {
    int x, y, val1, val2;
    Op(int x, int y, int val1, int val2) : x(x), y(y), val1(val1), val2(val2) {}
};

struct Query {
    int x, y, idx;

    Query() {}
    Query(int x, int y, int idx) : x(x), y(y), idx(idx) {}
};

struct FenwickTree {
    struct node {
        i64 a, b; //ax + b;

        node() : a(0), b(0) {}
        node(i64 a, i64 b) : a(a), b(b) {}
    
        node operator + (node rhs) {
            return node(a + rhs.a, b + rhs.b);
        }

        node operator - (node rhs) {
            return node(a - rhs.a, b - rhs.b);
        }

        i64 eval(i64 x) {
            return a * x + b;
        }
    };

    int n;
    vector<node> data;

    FenwickTree(int n) : n(n), data(n + 1) {}

    void reset() {
        data.assign(n + 1, node());
    }

    void update(int idx, node val) {
        if (idx < 1) return;
        // cout << idx << " " << val.a << " " << val.b << endl;
        while (idx <= n) {
            data[idx] = data[idx] + val;
            // cout << idx << " " << data[idx].a << " " << data[idx].b << endl;
            idx += idx & -idx;
        }
    }

    node get(int idx) {
        // cout << "get: " << idx << endl;
        node res;
        while (idx) {
            res = res + data[idx];
            idx -= idx & -idx;
        }
        return res;
    }

    node get(int l, int r) {
        return get(r) - get(l - 1);
    }
};

int n, m, q;
vector<Op> wte, stn, nwtse, setnw, swtne, rnwtse, rsetnw;
vector<Query> queries;
int ofs_x, ofs_y;
i64 ans[mxN];

// pretty copable

void add_wte(int x, int y, int val, int d) {
    x += ofs_x, y += ofs_y;
    wte.emplace_back(x, y, val, val * (-x + 1));
    wte.emplace_back(x + d, y, -val, val * (x + d - 1));
    // cout << x << " " << y << ": " << val << " " << val * (-x + 1) << endl;
    // cout << x + d << " " << y << ": " << -val << " " << val * (x + d - 1) << endl;
}

void west_to_east() {
    sort(all(wte), [&](Op A, Op B) {
        return A.x < B.x;
    });
    sort(all(queries), [&](Query A, Query B) {
        return A.x < B.x;
    });

    FenwickTree fenw(mxN - 5);
    int ptr = 0, ptrq = 0;
    for (int i = 1; i <= mxN - 5; ++i) {
        // cout << i << endl;
        while (ptr < isz(wte) && wte[ptr].x == i) {
            fenw.update(wte[ptr].y, {wte[ptr].val1, wte[ptr].val2});
            ++ptr;
        }
        // cout << endl;
        while (ptrq < isz(queries) && queries[ptrq].x == i) {
            ans[queries[ptrq].idx] += fenw.get(queries[ptrq].y).eval(i);
            ++ptrq;
        }
    }
}

void add_stn(int x, int y, int val, int d) {
    x += ofs_x, y += ofs_y;
    stn.emplace_back(x, y, val, val * (-y + 1));
    stn.emplace_back(x, y + d, -val, val * (y + d - 1));
}

void south_to_north() {
    sort(all(stn), [&](Op A, Op B) {
        return A.y < B.y;
    });
    sort(all(queries), [&](Query A, Query B) {
        return A.y < B.y;
    });

    FenwickTree fenw(mxN - 5);
    int ptr = 0, ptrq = 0;
    for (int i = 1; i <= mxN - 5; ++i) {
        // cout << i << endl;
        while (ptr < isz(stn) && stn[ptr].y == i) {
            fenw.update(stn[ptr].x, {stn[ptr].val1, stn[ptr].val2});
            ++ptr;
        }
        // cout << endl;
        while (ptrq < isz(queries) && queries[ptrq].y == i) {
            ans[queries[ptrq].idx] += fenw.get(queries[ptrq].x).eval(i);
            ++ptrq;
        }
    }
}

// bruh bruh lmao

void add_nwtse(int x, int y, int val, int d) {
    x += ofs_x, y += ofs_y;
    nwtse.emplace_back(x, y, val, val * (-y + 1));
    nwtse.emplace_back(x + d, y + d, -val, val * (y + d - 1));
    // cout << x << " " << y << " " << val << " " << val * (-y + 1) << endl;
    // cout << x + d << " " << y + d << " " << -val << " " << val * (y + d - 1) << endl;
}

void northwest_to_southeast() {
    sort(all(nwtse), [&](Op A, Op B) {
        return A.x - A.y < B.x - B.y;
    });
    sort(all(queries), [&](Query A, Query B) {
        return A.x - A.y < B.x - B.y;
    });

    FenwickTree fenw(mxN - 5);
    int ptr = 0, ptrq = 0;
    for (int i = 1 - (mxN - 5); i <= (mxN - 5) - 1; ++i) {
        // cout << i << endl;
        while (ptr < isz(nwtse) && nwtse[ptr].x - nwtse[ptr].y == i) {
            fenw.update(nwtse[ptr].y, {nwtse[ptr].val1, nwtse[ptr].val2});
            ++ptr;
        }
        // cout << endl;
        while (ptrq < isz(queries) && queries[ptrq].x - queries[ptrq].y == i) {
            ans[queries[ptrq].idx] += fenw.get(queries[ptrq].y).eval(queries[ptrq].y);
            ++ptrq;
        }
    }
}

void add_setnw(int x, int y, int val, int d) {
    x += ofs_x, y += ofs_y;
    setnw.emplace_back(x, y, val, val * (-x + 1));
    setnw.emplace_back(x + d, y + d, -val, val * (x + d - 1));
    // cout << "setnw: " << x << " " << y << " " << val << " " << val * (-x + 1) << endl;
    // cout << "setnw: " << x + d << " " << y + d << " " << -val << " " << val * (x + d - 1) << endl;
}

void southeast_to_northwest() {
    sort(all(setnw), [&](Op A, Op B) {
        return A.x - A.y > B.x - B.y;
    });
    sort(all(queries), [&](Query A, Query B) {
        return A.x - A.y > B.x - B.y;
    });

    FenwickTree fenw(mxN - 5);
    int ptr = 0, ptrq = 0;
    for (int i = (mxN - 5) - 1; i >= 1 - (mxN - 5); --i) {
        // cout << i << endl;
        while (ptr < isz(setnw) && setnw[ptr].x - setnw[ptr].y == i) {
            fenw.update(setnw[ptr].x, {setnw[ptr].val1, setnw[ptr].val2});
            ++ptr;
        }
        // cout << endl;
        while (ptrq < isz(queries) && queries[ptrq].x - (queries[ptrq].y - 1) == i) {
            ans[queries[ptrq].idx] += fenw.get(queries[ptrq].x).eval(queries[ptrq].x);
            ++ptrq;
        }
    }
}

pair<int, int> rotate_point(int x, int y) {
    // assert(y > 0 && 250000 - x + 1 > 0);
    return {y, 250000 - x + 1};
}

void add_rnwtse(int x, int y, int val, int d) {
    // if (x > mxN - 5 || y > mxN - 5) return;
    tie(x, y) = rotate_point(x, y);
    x += ofs_x, y += ofs_y;
    rnwtse.emplace_back(x, y, val, val * (-y + 1));
    rnwtse.emplace_back(x + d, y + d, -val, val * (y + d - 1));
    // cout << "rnwtse: " << x << " " << y << " " << val << " " << val * (-y + 1) << "\n";
    // cout << "rnwtse: " << x + d << " " << y + d << " " << -val << " " << val * (y + d - 1) << endl;
    // cout << x << " " << y << " " << val << endl;
}

void rotate_northwest_to_southeast() {
    sort(all(rnwtse), [&](Op A, Op B) {
        return A.x - A.y < B.x - B.y;
    });
    vector<Query> rqueries;
    for (auto [x, y, idx] : queries) {
        tie(x, y) = rotate_point(x, y);
        rqueries.emplace_back(x, mxN - 5, idx);
        rqueries.emplace_back(x, y - 1, -idx);
        // cout << x << " " << mxN - 5 << " " << y - 1 << endl;
    }
    sort(all(rqueries), [&](Query A, Query B) {
        return A.x - A.y < B.x - B.y;
    });

    FenwickTree fenw(mxN + 10);
    int ptr = 0, ptrq = 0;
    for (int i = -mxN; i <= mxN; ++i) {
        // cout << i << endl;
        while (ptr < isz(rnwtse) && rnwtse[ptr].x - rnwtse[ptr].y == i) {
            fenw.update(rnwtse[ptr].y + 1, {rnwtse[ptr].val1, rnwtse[ptr].val2});
            ++ptr;
        }
        // cout << endl;
        while (ptrq < isz(rqueries) && rqueries[ptrq].x - rqueries[ptrq].y == i) {
            int cidx = rqueries[ptrq].idx;
            ans[abs(cidx)] += fenw.get(rqueries[ptrq].y + 1).eval(rqueries[ptrq].y) * (cidx > 0 ? 1 : -1);
            ++ptrq;
        }
    }
}

void add_rsetnw(int x, int y, int val, int d) {
    // if (x > mxN - 5 || y > mxN - 5) return;
    tie(x, y) = rotate_point(x, y);
    x += ofs_x, y += ofs_y;
    rsetnw.emplace_back(x, y, val, val * (-x + 1));
    rsetnw.emplace_back(x + d, y + d, -val, val * (x + d - 1));
    // cout << "rsetnw: " << x << " " << y << " " << val << " " << val * (-x + 1) << endl;
    // cout << "rsetnw: " << x + d << " " << y + d << " " << -val << " " << val * (x + d - 1) << endl;
}

void rotate_southeast_to_northwest() {
    sort(all(rsetnw), [&](Op A, Op B) {
        return A.x - A.y > B.x - B.y;
    });
    vector<Query> rqueries;
    for (auto [x, y, idx] : queries) {
        tie(x, y) = rotate_point(x, y);
        // cout << x << " " << y << endl;
        rqueries.emplace_back(x, mxN - 5, idx);
        rqueries.emplace_back(x, y - 1, -idx);
    }
    sort(all(rqueries), [&](Query A, Query B) {
        return A.x - A.y > B.x - B.y;
    });

    FenwickTree fenw(mxN);
    int ptr = 0, ptrq = 0;
    for (int i = mxN; i >= -mxN; --i) {
        // cout << i << endl;
        while (ptr < isz(rsetnw) && rsetnw[ptr].x - rsetnw[ptr].y == i) {
            fenw.update(rsetnw[ptr].x, {rsetnw[ptr].val1, rsetnw[ptr].val2});
            ++ptr;
        }
        // cout << endl;
        while (ptrq < isz(rqueries) && rqueries[ptrq].x - (rqueries[ptrq].y - 1) == i) {
            int cidx = rqueries[ptrq].idx;
            ans[abs(cidx)] += fenw.get(rqueries[ptrq].x).eval(rqueries[ptrq].x) * (cidx > 0 ? 1 : -1);
            ++ptrq;
        }
    }
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m, q;
    cin >> n >> m >> q;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i].x1 >> a[i].y1 >> a[i].x2 >> a[i].y2;
        ofs_x = 0, ofs_y = 0;
        add_wte(a[i].x1, a[i].y1, 1, 1);
        add_wte(a[i].x2 + 1, a[i].y1, -1, 1);
        add_wte(a[i].x1, a[i].y2 + 1, -1, 1);
        add_wte(a[i].x2 + 1, a[i].y2 + 1, 1, 1);
    }

    for (int i = 1; i <= m; ++i) {
        int tp, idx, d;
        cin >> tp >> idx >> d;
        if (tp == 0) { // (1, 0)
            ofs_x = 1, ofs_y = 0;
            add_wte(a[idx].x1, a[idx].y1, 1, d);
            add_wte(a[idx].x2 + 1, a[idx].y1, -1, d);
            add_wte(a[idx].x1, a[idx].y2 + 1, -1, d);
            add_wte(a[idx].x2 + 1, a[idx].y2 + 1, 1, d);
            a[idx].apply(d, 0);
        }
        else if (tp == 1) { // (1, 1)
            ofs_x = 1, ofs_y = 1;
            add_nwtse(a[idx].x1, a[idx].y1, 1, d);
            add_nwtse(a[idx].x2 + 1, a[idx].y1, -1, d);
            add_nwtse(a[idx].x1, a[idx].y2 + 1, -1, d);
            add_nwtse(a[idx].x2 + 1, a[idx].y2 + 1, 1, d);
            add_setnw(a[idx].x1, a[idx].y1, 1, d);
            add_setnw(a[idx].x2 + 1, a[idx].y1, -1, d);
            add_setnw(a[idx].x1, a[idx].y2 + 1, -1, d);
            add_setnw(a[idx].x2 + 1, a[idx].y2 + 1, 1, d);
            a[idx].apply(d, d);
        }
        else if (tp == 2) { // (0, 1)
            ofs_x = 0, ofs_y = 1;
            add_stn(a[idx].x1, a[idx].y1, 1, d);
            add_stn(a[idx].x2 + 1, a[idx].y1, -1, d);
            add_stn(a[idx].x1, a[idx].y2 + 1, -1, d);
            add_stn(a[idx].x2 + 1, a[idx].y2 + 1, 1, d);
            a[idx].apply(0, d);
        }
        else if (tp == 3) { // (-1, 1)
            ofs_x = 1, ofs_y = 1;
            add_rnwtse(a[idx].x1, a[idx].y1, 1, d);
            add_rnwtse(a[idx].x2 + 1, a[idx].y1, -1, d);
            add_rnwtse(a[idx].x1, a[idx].y2 + 1, -1, d);
            add_rnwtse(a[idx].x2 + 1, a[idx].y2 + 1, 1, d);
            add_rsetnw(a[idx].x1, a[idx].y1, 1, d);
            add_rsetnw(a[idx].x2 + 1, a[idx].y1, -1, d);
            add_rsetnw(a[idx].x1, a[idx].y2 + 1, -1, d);
            add_rsetnw(a[idx].x2 + 1, a[idx].y2 + 1, 1, d);
            a[idx].apply(-d, d);
        }
        else if (tp == 4) { // (-1, 0)
            a[idx].apply(-d, 0);
            ofs_x = 0, ofs_y = 0;
            add_wte(a[idx].x1, a[idx].y1, 1, d);
            add_wte(a[idx].x2 + 1, a[idx].y1, -1, d);
            add_wte(a[idx].x1, a[idx].y2 + 1, -1, d);
            add_wte(a[idx].x2 + 1, a[idx].y2 + 1, 1, d);
            // cout << endl;
        }
        else if (tp == 5) { // (-1, -1)
            a[idx].apply(-d, -d);
            ofs_x = 0, ofs_y = 0;
            add_nwtse(a[idx].x1, a[idx].y1, 1, d);
            add_nwtse(a[idx].x2 + 1, a[idx].y1, -1, d);
            add_nwtse(a[idx].x1, a[idx].y2 + 1, -1, d);
            add_nwtse(a[idx].x2 + 1, a[idx].y2 + 1, 1, d);
            add_setnw(a[idx].x1, a[idx].y1, 1, d);
            add_setnw(a[idx].x2 + 1, a[idx].y1, -1, d);
            add_setnw(a[idx].x1, a[idx].y2 + 1, -1, d);
            add_setnw(a[idx].x2 + 1, a[idx].y2 + 1, 1, d);
        }
        else if (tp == 6) { // (0, -1)
            a[idx].apply(0, -d);
            ofs_x = 0, ofs_y = 0;
            add_stn(a[idx].x1, a[idx].y1, 1, d);
            add_stn(a[idx].x2 + 1, a[idx].y1, -1, d);
            add_stn(a[idx].x1, a[idx].y2 + 1, -1, d);
            add_stn(a[idx].x2 + 1, a[idx].y2 + 1, 1, d);
        }
        else { // (1, -1)
            a[idx].apply(d, -d);
            ofs_x = 0, ofs_y = 0;
            add_rnwtse(a[idx].x1, a[idx].y1, 1, d);
            add_rnwtse(a[idx].x2 + 1, a[idx].y1, -1, d);
            add_rnwtse(a[idx].x1, a[idx].y2 + 1, -1, d);
            add_rnwtse(a[idx].x2 + 1, a[idx].y2 + 1, 1, d);
            add_rsetnw(a[idx].x1, a[idx].y1, 1, d);
            add_rsetnw(a[idx].x2 + 1, a[idx].y1, -1, d);
            add_rsetnw(a[idx].x1, a[idx].y2 + 1, -1, d);
            add_rsetnw(a[idx].x2 + 1, a[idx].y2 + 1, 1, d);
        }
    }

    for (int i = 1; i <= q; ++i) {
        int x, y;
        cin >> x >> y;
        queries.emplace_back(x, y, i);
    }

    west_to_east();
    south_to_north();
    northwest_to_southeast();
    southeast_to_northwest();
    rotate_northwest_to_southeast();
    rotate_southeast_to_northwest();

    for (int i = 1; i <= q; ++i) {
        cout << ans[i] << "\n";
    }
}