#include <bits/stdc++.h>

using namespace std;

vector< int > nums;

inline int access(int idx)
{
  return (nums[min((int) nums.size() - 1, idx)]);
}


template< typename T >
struct SegmentTree
{
  vector< T > seg, add;
  int sz;

  SegmentTree(int n)
  {
    sz = 1;
    while(sz < n) sz <<= 1;
    seg.assign(2 * sz - 1, 0);
    add.assign(2 * sz - 1, 0);
  }

  T merge(T a, T b)
  {
    return (a + b);
  }

  void set(int k, int x)
  {
    seg[k + sz - 1] = x;
  }

  void build()
  {
    for(int k = sz - 2; k >= 0; k--) {
      seg[k] = merge(seg[2 * k + 1], seg[2 * k + 2]);
    }
  }

  T rmq(int a, int b, int k, int l, int r)
  {
    if(a >= r || b <= l) return (0);
    if(a <= l && r <= b) return (seg[k] + add[k] * (access(r) - access(l)));
    return (merge(rmq(a, b, 2 * k + 1, l, (l + r) >> 1),
                  rmq(a, b, 2 * k + 2, (l + r) >> 1, r)) +
            (add[k] * (min(access(r), access(b)) - max(access(l), access(a)))));
  }

  T rmq(int a, int b)
  {
    return (rmq(a, b, 0, 0, sz));
  }

  void rangeadd(int a, int b, T x, int k, int l, int r)
  {
    if(a >= r || b <= l) return;
    if(a <= l && r <= b) {
      add[k] += x;
      return;
    }
    rangeadd(a, b, x, 2 * k + 1, l, (l + r) >> 1);
    rangeadd(a, b, x, 2 * k + 2, (l + r) >> 1, r);
    seg[k] += x * (min(access(r), access(b)) - max(access(a), access(l)));
  }

  void rangeadd(int a, int b, T x)
  {
    rangeadd(a, b, x, 0, 0, sz);
  }
};

using int64 = long long;

int main()
{
  int N, M, Q;
  int A[100000], B[100000], C[100000];
  int X[100000], Y[100000];
  int64 Z[100000];
  int L[100000], R[100000];

  scanf("%d %d %d", &N, &M, &Q);

  for(int i = 0; i < M; i++) {
    scanf("%d %d %d", &A[i], &B[i], &C[i]);
    --A[i];
    nums.emplace_back(A[i]);
    nums.emplace_back(B[i]);
  }

  for(int i = 0; i < Q; i++) {
    scanf("%d %d %lld", &X[i], &Y[i], &Z[i]);
    --X[i];
    L[i] = 0, R[i] = M - 1;
    nums.emplace_back(X[i]);
    nums.emplace_back(Y[i]);
  }
  sort(begin(nums), end(nums));
  nums.erase(unique(begin(nums), end(nums)), end(nums));

  for(int i = 0; i < M; i++) {
    A[i] = lower_bound(begin(nums), end(nums), A[i]) - begin(nums);
    B[i] = lower_bound(begin(nums), end(nums), B[i]) - begin(nums);
  }
  for(int i = 0; i < Q; i++) {
    X[i] = lower_bound(begin(nums), end(nums), X[i]) - begin(nums);
    Y[i] = lower_bound(begin(nums), end(nums), Y[i]) - begin(nums);
  }

  vector< int > order(M);
  iota(begin(order), end(order), 0);
  sort(begin(order), end(order), [&](int a, int b)
  {
    return (C[a] < C[b]);
  });

  for(int i = 0; i < 17; i++) {
    vector< pair< int, int > > mid(Q);
    for(int j = 0; j < Q; j++) {
      mid[j] = {(L[j] + R[j]) / 2, j};
    }
    sort(begin(mid), end(mid));
    int tail = 0;
    SegmentTree< int64 > tree(nums.size());
    for(int j = 0; j < M; j++) {
      tree.rangeadd(A[order[j]], B[order[j]], 1);
      while(tail < Q && mid[tail].first == j) {
        const int idx = mid[tail].second;
        if(tree.rmq(X[idx], Y[idx]) >= Z[idx]) R[idx] = j;
        else L[idx] = j + 1;
        ++tail;
      }
    }
  }

  for(int i = 0; i < Q; i++) {
    printf("%d\n", C[order[L[i]]]);
  }
}

Measured memory_bytes: 25556