#define _CRT_SECURE_NO_DEPRECATE
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <tuple>
using namespace std;

typedef long long ll;

struct TNode {
    ll sumA, sumK;
    TNode *left;
    TNode *right;
    void up() {
        sumA = left->sumA + right->sumA;
        sumK = left->sumK + right->sumK;
    }
};

TNode nodePool[10000000];
int poolPtr = 0;

TNode* allocNode() {
    return &nodePool[poolPtr++];
}

TNode* copyNode(TNode* p) {
    TNode* res = allocNode();
    res->left = p->left;
    res->right = p->right;
    res->sumA = p->sumA;
    res->sumK = p->sumK;
    return res;
}

TNode* addElement(TNode* current, int p, int level, ll valA, ll valK) {
    current = copyNode(current);
    if (level == 0) {
        if (p != 0) abort();
        current->sumA += valA;
        current->sumK += valK;
    } else {
        if (p < (1<<(level - 1))) {
            current->left = addElement(current->left, p, level-1, valA, valK);
        } else {
            current->right = addElement(current->right, p - (1<<(level - 1)), level-1, valA, valK);
        }
        current->up();
    }
    return current;
}

ll getCount(TNode* c, int p, int level, int time) {
    if (level == 0) {
        return 0; //time*c->sumK + c->sumA;
    }
    if (p < (1<<(level - 1)))
        return getCount(c->left, p, level - 1, time);
    else
        return time*c->left->sumK + c->left->sumA + getCount(c->right, p - (1<<(level - 1)), level - 1, time);
}

vector<int> uniqVs;
vector<int> uniqXs;

inline int getIndex(const vector<int>& uniqs, int v) {
    return lower_bound(uniqs.begin(), uniqs.end(), v) - uniqs.begin();
}

TNode* init(int level) {
    TNode* n = allocNode();
    n->sumA = 0;
    n->sumK = 0;
    if (level != 0) {
        n->left = init(level - 1);
        n->right = init(level - 1);
    }
    return n;
}

int main(void) {
    int n, m, q;
    scanf("%d%d%d", &n, &m, &q);
    typedef tuple<int, int, int, int> TAddReq;
    vector<TAddReq> addReqs;
    for (int i = 0; i < m; ++i) {
        int a, b, v;
        scanf("%d%d%d", &a, &b, &v);
        uniqVs.push_back(v);
        uniqXs.push_back(a);
        uniqXs.push_back(b);
        addReqs.push_back(TAddReq(a, v, -a + 1, 1));
        addReqs.push_back(TAddReq(b + 1, v, b, -1));
    }
    ///////
    sort(uniqVs.begin(), uniqVs.end());
    uniqVs.erase(unique(uniqVs.begin(), uniqVs.end()), uniqVs.end());
    ///////
    sort(uniqXs.begin(), uniqXs.end());
    uniqXs.erase(unique(uniqXs.begin(), uniqXs.end()), uniqXs.end());
    ///////
    sort(addReqs.begin(), addReqs.end());
    vector<TNode*> trees;
    const int level = 17;
    trees.push_back(init(level));
    for (int i = 0; i < (int)addReqs.size(); ++i) {
        trees.push_back(addElement(trees.back(), getIndex(uniqVs, get<1>(addReqs[i])), level, get<2>(addReqs[i]), get<3>(addReqs[i])));
    }
    for (int i = 0; i < q; ++i) {
        int x, y;
        ll j;
        scanf("%d%d%lld", &x, &y, &j);
        int idx1 = lower_bound(addReqs.begin(), addReqs.end(), TAddReq(x, -1, -1, -1)) - addReqs.begin();
        TNode *t1 = trees[idx1];
        int idx2 = lower_bound(addReqs.begin(), addReqs.end(), TAddReq(y+1, -1, -1, -1)) - addReqs.begin();
        TNode *t2 = trees[idx2];
        int l = 0, r = (int)uniqVs.size();
        while (r - l != 1) {
            int med = (l + r) / 2;
            ll cur = getCount(t2, med, level, y) - getCount(t1, med, level, x - 1);
            if (cur >= j) {
                r = med;
            } else {
                l = med;
            }
        }
        printf("%d\n", uniqVs[l]);
    }
    return 0;
}