#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <cmath>

typedef long long ll;
typedef double lf;

// #define DEBUG 1
struct IO
{
    #define MAXSIZE (1 << 20)
    #define isdigit(x) (x >= '0' && x <= '9')
    char buf[MAXSIZE], *p1, *p2;
    char pbuf[MAXSIZE], *pp;
    #if DEBUG
    #else
    IO() : p1(buf), p2(buf), pp(pbuf) {}
    ~IO() {fwrite(pbuf, 1, pp - pbuf, stdout);}
    #endif
    #define gc() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, MAXSIZE, stdin), p1 == p2) ? ' ' : *p1++)
    #define blank(x) (x == ' ' || x == '\n' || x == '\r' || x == '\t')

    template <typename T>
    void Read(T &x)
    {
        #if DEBUG
        std::cin >> x;
        #else
        bool sign = 0; char ch = gc(); x = 0;
        for (; !isdigit(ch); ch = gc())
            if (ch == '-') sign = 1;
        for (; isdigit(ch); ch = gc()) x = x * 10 + (ch ^ 48);
        if (sign) x = -x;
        #endif
    }
    void Read(char *s)
    {
        #if DEBUG
        std::cin >> s;
        #else
        char ch = gc();
        for (; blank(ch); ch = gc());
        for (; !blank(ch); ch = gc()) *s++ = ch;
        *s = 0;
        #endif
    }
    void Read(char &c) {for (c = gc(); blank(c); c = gc());}

    void Push(const char &c)
    {
        #if DEBUG
        putchar(c);
        #else
        if (pp - pbuf == MAXSIZE) fwrite(pbuf, 1, MAXSIZE, stdout), pp = pbuf;
        *pp++ = c;
        #endif
    }
    template <typename T>
    void Write(T x)
    {
        if (x < 0) x = -x, Push('-');
        static T sta[35];
        int top = 0;
        do sta[top++] = x % 10, x /= 10; while (x);
        while (top) Push(sta[--top] ^ 48);
    }
    template <typename T>
    void Write(T x, char lst) {Write(x), Push(lst);}
} IO;
#define Read(x) IO.Read(x)
#define Write(x, y) IO.Write(x, y)
#define Put(x) IO.Push(x)

using namespace std;

const int MAXN = 3e5 + 10;

int n, m, q;

struct Line
{
    int l, r, x;
    Line(int _l, int _r, int _x) : l(_l), r(_r), x(_x) {}
    bool operator < (const Line u) const {return (l == u.l ? r < u.r : l < u.l);}
};
vector <Line> vec[MAXN];

int d = 1e8;
set <Line> st;
inline auto Split(int x)
{
    auto it = --st.upper_bound(Line(x, 2e9, 0));
    if (it -> l == x) return it;
    int l = it -> l, r = it -> r, v = it -> x;
    st.erase(it), st.insert(Line(l, x - 1, v));
    return st.insert(Line(x, r, v)).first;
}

struct Data
{
    int l, r, x, y;
}g1[MAXN * 3], g2[MAXN * 3];
int t1, t2;
struct Qry
{
    int t, x, ans;
}qt[MAXN];
int b[MAXN << 2], tot, c[MAXN << 1], top;

struct Node
{
    int ls, rs, val;
}tr[MAXN * 200];
int nd, rt[MAXN << 2];
void Update(int &cur, int pre, int l, int r, int x, int y, int k)
{
    cur = ++nd, tr[cur] = tr[pre];
    // cerr << "upd " << cur  << ' ' << pre << ' ' << l << ' ' << r << ' ' << x << ' ' << y << ' ' << k << ' ';
    if (x <= l && r <= y) tr[cur].val = max(tr[cur].val, k);//, cerr << tr[cur].val << '\n';
    else
    {
        // cerr << tr[cur].val << '\n';
        int mid = l + r >> 1;
        if (x <= mid) Update(tr[cur].ls, tr[pre].ls, l, mid, x, y, k);
        if (y > mid) Update(tr[cur].rs, tr[pre].rs, mid + 1, r, x, y, k);
    }
}
int Query(int cur, int l, int r, int x)
{
    // cerr << "qry " << cur << ' ' << l << ' ' << r << ' ' << x << ' ' << tr[cur].val << '\n';
    if (!cur) return -2e9;
    if (l == r) return tr[cur].val;
    int mid = l + r >> 1;
    if (x <= mid) return max(tr[cur].val, Query(tr[cur].ls, l, mid, x));
    return max(tr[cur].val, Query(tr[cur].rs, mid + 1, r, x));
}

vector <int> qry[MAXN << 2], upd[MAXN << 2];
void InsertUpdate(int cur, int l, int r, int x, int y, int id)
{
    // cerr << "Inupd " << cur << ' ' << l << ' ' << r << ' ' << x << ' ' << y << ' ' << id << '\n';
    if (x <= l && r <= y) upd[cur].push_back(id);
    else
    {
        int mid = l + r >> 1;
        if (x <= mid) InsertUpdate(cur << 1, l, mid, x, y, id);
        if (y > mid) InsertUpdate(cur << 1 | 1, mid + 1, r, x, y, id);
    }
}
void InsertQuery(int cur, int l, int r, int x, int id)
{
    if (l == r) qry[cur].push_back(id);
    else
    {
        int mid = l + r >> 1;
        if (x <= mid) InsertQuery(cur << 1, l, mid, x, id);
        else InsertQuery(cur << 1 | 1, mid + 1, r, x, id);
    }
}
void Solve(int cur, int fa, int l, int r, bool tp, bool fl)
{
    rt[cur] = rt[fa];
    if (!fl)
    {
        // cerr << "Solve " << cur << ' ' << rt[cur] << ' ' << l << ' ' << r << '\n';
        for (auto id : upd[cur])
            if (!tp)
            {
                if (g1[id].y == 2e9) {fl = 1; break;}
                Update(rt[cur], rt[fa], 1, top, g1[id].x, g1[id].y, g1[id].y);
            }
            else Update(rt[cur], rt[fa], 1, top, g2[id].x, g2[id].y, -g2[id].x);
    }
    if (l == r)
    {
        for (auto id : qry[cur])
            if (fl || qt[id].ans == -1) qt[id].ans = -1;
            else
            {
                int res = Query(rt[cur], 1, top, qt[id].x);
                if (res == -2e9) continue;
                if (tp) res = -res;
                // cerr << res << '\n';
                qt[id].ans = max(qt[id].ans, abs(c[qt[id].x] - c[res]));
            }
        return;
    }
    int mid = l + r >> 1;
    Solve(cur << 1, cur, l, mid, tp, fl), Solve(cur << 1 | 1, cur, mid + 1, r, tp, fl);
}

int main()
{
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    #if DEBUG
    #else
    ios::sync_with_stdio(0), cin.tie(0);
    #endif
    Read(n), Read(m), Read(q);
    for (int i = 1, x, t, l, r; i <= n; i++)
    {
        Read(x), Read(t), Read(l), Read(r);
        vec[t].emplace_back(l, r, x);
        b[++tot] = l, b[++tot] = r, c[++top] = x;
    }
    for (int i = 1; i <= m; i++)
    {
        st.clear(), st.insert(Line(1, d, 0));
        sort(vec[i].begin(), vec[i].end(), [&](Line u, Line v) {return u.x < v.x;});
        for (auto t : vec[i])
        {
            int l = t.l, r = t.r, x = t.x, mid;
            // cout << l << ' ' << r << ' ' << x << '\n';
            auto ed = Split(r + 1), bg = Split(l);
            for (auto it = bg; it != ed; it++)
            {
                if (it -> x == 0) g1[++t1] = Data{it -> l, it -> r, 1, x};
                else mid = x + it -> x >> 1, g1[++t1] = Data{it -> l, it -> r, mid + 1, x}, g2[++t2] = Data{it -> l, it -> r, it -> x, mid};
            }
            st.erase(bg, ed);
            st.insert(Line{l, r, x});
            // for (auto x : st) cout << x.l << ' ' << x.r << '\n';
            // cout << '\n';
        }
        for (auto it : st)
            if (it.x == 0) g1[++t1] = Data{it.l, it.r, 1, (int)2e9};
            else g2[++t2] = Data{it.l, it.r, it.x, d};
    }
    // cerr << "ODT\n";
    // for (int i = 1; i <= t2; i++) cerr << g2[i].l << ' ' << g2[i].r << ' ' << g2[i].x << ' ' << g2[i].y << "\n";
    for (int i = 1; i <= q; i++) Read(qt[i].x), Read(qt[i].t), b[++tot] = qt[i].t, c[++top] = qt[i].x;
    b[++tot] = c[++top] = 2e9;
    sort(b + 1, b + tot + 1), tot = unique(b + 1, b + tot + 1) - b - 1;
    sort(c + 1, c + top + 1), top = unique(c + 1, c + top + 1) - c - 1;
    // cerr << "##\n";
    for (int i = 1; i <= q; i++)
    {
        qt[i].t = lower_bound(b + 1, b + tot + 1, qt[i].t) - b;
        qt[i].x = lower_bound(c + 1, c + top + 1, qt[i].x) - c;
        // cerr << qt[i].t << ' ' << qt[i].x << '\n';
        InsertQuery(1, 1, tot, qt[i].t, i);
    }
    // cerr << "insert q\n";
    for (int i = 1; i <= t1; i++)
    {
        g1[i].l = lower_bound(b + 1, b + tot + 1, g1[i].l) - b, g1[i].r = lower_bound(b + 1, b + tot + 1, g1[i].r) - b;
        g1[i].x = lower_bound(c + 1, c + top + 1, g1[i].x) - c;
        if (g1[i].y != 2e9) g1[i].y = upper_bound(c + 1, c + top + 1, g1[i].y) - c - 1;
        if (g1[i].r <= tot) InsertUpdate(1, 1, tot, g1[i].l, g1[i].r, i);
    }
    // cerr << "insert 0\n";
    tr[rt[0] = 0].val = -2e9;
    Solve(1, 0, 1, tot, 0, 0);
    // cerr << "Solve -----------------\n";
    for (int i = 1; i <= tot * 4; i++) upd[i].clear(), rt[i] = 0;
    for (int i = 1; i <= t2; i++)
    {
        g2[i].l = lower_bound(b + 1, b + tot + 1, g2[i].l) - b, g2[i].r = lower_bound(b + 1, b + tot + 1, g2[i].r) - b;
        g2[i].x = lower_bound(c + 1, c + top + 1, g2[i].x) - c, g2[i].y = upper_bound(c + 1, c + top + 1, g2[i].y) - c - 1;
        // cerr << g2[i].l << ' ' << g2[i].r << ' ' << g2[i].x << ' ' << g2[i].y << '\n';
        if (g2[i].r <= tot) InsertUpdate(1, 1, tot, g2[i].l, g2[i].r, i);
    }
    nd = 0, Solve(1, 0, 1, tot, 1, 0);
    for (int i = 1; i <= q; i++) cout << qt[i].ans << '\n';
    return 0;
}