#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <climits>
#include <ctime>
#include <queue>
#include <stack>
#include <algorithm>
#include <list>
#include <vector>
#include <set>
#include <map>
#include <iostream>
#include <deque>
#include <complex>
#include <string>
#include <iomanip>
#include <sstream>
#include <bitset>
#include <valarray>
#include <unordered_map>
#include <iterator>
#include <functional>
#include <cassert>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

#define REP(i,x) for(int i=0;i<(int)(x);i++)
#define REPS(i,x) for(int i=1;i<=(int)(x);i++)
#define RREP(i,x) for(int i=((int)(x)-1);i>=0;i--)
#define RREPS(i,x) for(int i=((int)(x));i>0;i--)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();i++)
#define RFOR(i,c) for(__typeof((c).rbegin())i=(c).rbegin();i!=(c).rend();i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) ((int)container.size())
#define mp(a,b) make_pair(a, b)
#define pb push_back
#define eb emplace_back
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );

template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
os<<"["; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"]"; return os;
}
template<class T> ostream& operator<<(ostream &os, const set<T> &t) {
os<<"{"; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"}"; return os;
}
template<class S, class T> ostream& operator<<(ostream &os, const pair<S,T> &t) { return os<<"("<<t.first<<","<<t.second<<")";}
template<class S, class T> pair<S,T> operator+(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first+t.first, s.second+t.second);}
template<class S, class T> pair<S,T> operator-(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first-t.first, s.second-t.second);}

const int INF = 1<<28;
const double EPS = 1e-8;
const int MOD = 1000000007;

template<typename Handler, int RESERVE = (1<<29)>
struct SegTreeDynamicLazy{
	typedef typename Handler::val_t val_t;
	typedef typename Handler::opr_t opr_t;
	Handler hdl;
	struct Node{
		static Node *pool;
		static int ptr;
		static int New(const Node *v){
			if(!pool) pool = (Node*)malloc(RESERVE);
			pool[++ptr] = v ? *v : Node();
			return ptr;
		}
		static void allClear(){
			ptr = 0;
		}
		int lch, rch;
		val_t val;
		opr_t lazy;
		Node(Node *v=0):val(Handler::def_val()), lazy(Handler::def_lazy()){
			if(v){
				(*this) = *v;
			}else lch = rch = 0;
		}
	};
	int root;
	ll n;
	Node *p;
	
	SegTreeDynamicLazy(ll size):hdl(),n(size){
		root = Node::New(0);
		p = Node::pool;
	}
	
	
	int push(int v, ll l, ll r, const int &pers=0){
		if(p[v].lazy == hdl.def_lazy()) return v;
		opr_t lz = p[v].lazy;
		p[v].lazy = hdl.def_lazy();
		if(r-l<=1) return v;
		if(pers || !p[v].lch) p[v].lch = Node::New(&p[p[v].lch]);
		if(pers || !p[v].rch) p[v].rch = Node::New(&p[p[v].rch]);
		p[p[v].lch].lazy = hdl.push(p[p[v].lch].lazy, lz);
		p[p[v].rch].lazy = hdl.push(p[p[v].rch].lazy, lz);
		p[p[v].lch].val = hdl.resolve(p[p[v].lch].val, lz, l, (l+r)/2);
		p[p[v].rch].val = hdl.resolve(p[p[v].rch].val, lz, (l+r)/2, r);
		return v;
	}
	int update(ll a,ll b,const opr_t &x, int v,ll l,ll r, const int &pers){
		if(r<=a||b<=l) return v;
		if(pers || !v) v = Node::New(&p[v]);
		if(a<=l&&r<=b){
			p[v].lazy = hdl.push(p[v].lazy, x);
			p[v].val = hdl.resolve(p[v].val, x, l, r);
			return v;
		}
		push(v, l, r, pers);
		p[v].lch = update(a, b, x, p[v].lch, l, (l+r)/2, pers);
		p[v].rch = update(a, b, x, p[v].rch, (l+r)/2, r, pers);
		p[v].val = hdl.merge(p[v].lch ? p[p[v].lch].val : hdl.def_val(), p[v].rch ? p[p[v].rch].val : hdl.def_val());
		return v;
	}
	val_t query(ll a,ll b,int v,ll l,ll r, opr_t lazy){
		if(r<=a||b<=l) return hdl.def_val();
		if(!v) return hdl.resolve(hdl.def_val(), lazy, max(l, a), min(r, b));
		if(a<=l&&r<=b) return hdl.resolve(p[v].val, lazy, l, r);
		lazy = hdl.push(p[v].lazy, lazy);
		return hdl.merge(query(a, b, p[v].lch, l, (l+r)/2, lazy), 
						 query(a, b, p[v].rch, (l+r)/2, r, lazy));
	}
	int update(ll a, ll b, opr_t x, int r = 0, int pers=0){return update(a, b, x, r?r:root, 0, n, pers);}
	val_t query(ll a, ll b, int r = 0){	return query(a, b, r?r:root, 0, n, hdl.def_lazy());}
	val_t operator[](size_t i){return query(i, i+1);}
	friend ostream& operator<<(ostream &os, SegTreeDynamicLazy<Handler> &t){
		REP(i, t.n) os << (i ? ", " : "[") << "(" << i << ")" << t.query(i, i+1);
		return os << "]";
	}
};
template<class H, int R> typename SegTreeDynamicLazy<H, R>::Node* SegTreeDynamicLazy<H, R>::Node::pool;
template<class H, int R> int SegTreeDynamicLazy<H, R>::Node::ptr;

struct handler{
	typedef ll val_t;
	typedef int opr_t;
	handler(){}
	inline static val_t def_val(){ return 0; }
	inline static opr_t def_lazy(){ return 0; }
	inline static val_t resolve(const val_t &x, const opr_t &y, ll l, ll r){
		return x + y*(r-l);
	}
	inline static opr_t push(const opr_t &x, const opr_t &y){
		return x + y;
	}
	inline static val_t merge(const val_t &x, const val_t &y){
		return x + y;
	}
};


int T, n, m, q;

int main(int argc, char *argv[]){
	ios::sync_with_stdio(false);
	scanf("%d%d%d", &n, &m, &q);
	vector<tuple<ll, int, int>> adds;
	REP(i, m){
		int a, b;
		ll v;
		scanf("%d%d%lld", &a, &b, &v); a--;
		adds.eb(v, a, b);
	}
	SegTreeDynamicLazy<handler> seg(n);
	vector<int> ptrs;
	ptrs.pb(seg.root);
	sort(ALL(adds));
	REP(i, m){
		int a, b, v;
		tie(v, a, b) = adds[i];
		ptrs.eb(seg.update(a, b, 1, ptrs.back(), 1));
	}
	REP(i, q){
		int x, y;
		ll j;
		scanf("%d%d%lld", &x, &y, &j); x--;
		int l = 0, r = m;
		while(l+1 < r){
			int mid = (l+r)/2;
			if(seg.query(x, y, ptrs[mid]) < j) l = mid;
			else r = mid;
		}
		printf("%lld\n", get<0>(adds[l]));
	}
	return 0;
}

Measured memory_bytes: 431264