// implement 43min
// debug 35min
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <set>

using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))

struct Query {
  ll l;
  ll r;
  ll v;
  int index;
  Query() {;}
  Query(ll l, ll r, ll v, int index) : l(l), r(r), v(v), index(index) {;}
  bool operator<(const Query &rhs) const {
    return v < rhs.v;
  }
};

ll n, m, q;
// return sequence sum
vector<ll> Imos(int index, const vector<ll> &xs, const vector<Query> &range) {
  vector<ll> sums(xs.size(), 0);
  REP(i, index) {
    sums[range[i].l] += 1;
    sums[range[i].r] -= 1;
  }
  ll lsum = 0;
  FOR(i, 1, xs.size()) {
    ll v = lsum * (xs[i] - xs[i - 1]) + sums[i - 1];
    lsum += sums[i]; // different value
    sums[i] = v; // sum value
  }

  return sums;
}

vector<ll> Compress(vector<Query> &range, vector<Query> &query) {
  map<ll, ll> mapto;
  mapto[-1] = 0;
  mapto[0] = 0;
  FORIT(it, range) {
    mapto[it->l] = 0;
    mapto[it->r] = 0;
  }
  FORIT(it, query) {
    mapto[it->l] = 0;
    mapto[it->r] = 0;
  }
  vector<ll> xs(mapto.size());
  {
    int index = 0;
    FORIT(it, mapto) {
      it->second = index;
      xs[index] = it->first;
      index++;
    }
    FORIT(it, range) {
      it->l = mapto[it->l];
      it->r = mapto[it->r];
    }
    FORIT(it, query) {
      it->l = mapto[it->l];
      it->r = mapto[it->r];
    }
  }
  return xs;
}

char used[1000010];
int mapto[1000010];
void Compress2(vector<ll> &xs, vector<Query> &range, vector<Query> &query) {
  memset(used, 0, sizeof(char) * xs.size());
  used[0] = 1;
  used[1] = 1;
  FORIT(it, range) {
    used[it->l] = 1;
    used[it->r] = 1;
  }
  FORIT(it, query) {
    used[it->l] = 1;
    used[it->r] = 1;
  }

  {
    int index = 0;
    REP(i, xs.size()) {
      if (!used[i]) { continue; }
      xs[index] = xs[i];
      mapto[i] = index;
      index++;
    }
    xs.resize(index);
    FORIT(it, range) {
      it->l = mapto[it->l];
      it->r = mapto[it->r];
    }
    FORIT(it, query) {
      it->l = mapto[it->l];
      it->r = mapto[it->r];
    }
  }
}

void Calc(vector<ll> &xs, vector<Query> &range, vector<Query> &query, vector<ll> &anss) {
  assert(range.size() != 0);
  // end case
  if (query.size() == 0) { return; }
  if (range.size() == 1) {
    FORIT(it, query) {
      anss[it->index] = range[0].v;
    }
    return;
  }

  Compress2(xs, range, query);
  int t = range.size() / 2;
  vector<ll> sums = Imos(t, xs, range);
  vector<Query> lquery, rquery;
  REP(i, query.size()) {
    ll s = sums[query[i].r] - sums[query[i].l];
    if (s >= query[i].v) {
      lquery.push_back(query[i]);
    } else {
      query[i].v -= s;
      rquery.push_back(query[i]);
    }
  }
  query.clear();

  vector<Query> lrange, rrange;
  FOR(i, 0, t) { lrange.push_back(range[i]); }
  FOR(i, t, range.size()) { rrange.push_back(range[i]); }
  range.clear();

  if (lrange.size() + lquery.size() < rrange.size() + rquery.size()) {
    vector<ll> nxs = xs;
    Calc(nxs, lrange, lquery, anss);
    nxs.clear();
    Calc(xs, rrange, rquery, anss);
  } else {
    vector<ll> nxs = xs;
    Calc(nxs, rrange, rquery, anss);
    nxs.clear();
    Calc(xs, lrange, lquery, anss);
  }
}

int main() {
  while (scanf("%lld %lld %lld", &n, &m, &q) > 0) {
    // Input
    vector<Query> range(m);
    vector<Query> query(q);
    REP(i, m) {
      ll a, b, c;
      int v = scanf("%lld %lld %lld", &a, &b, &c);
      a--;
      assert(v == 3);
      range[i] = Query(a, b, c, i);
    }
    REP(i, q) {
      ll a, b, c;
      int v = scanf("%lld %lld %lld", &a, &b, &c);
      a--;
      assert(v == 3);
      query[i] = Query(a, b, c, i);
    }
    sort(range.begin(), range.end());
    vector<ll> xs = Compress(range, query);

    // Calc Answer
    vector<ll> anss(q);
    Calc(xs, range, query, anss);
    REP(i, q) {
      printf("%lld\n", anss[i]);
    }
  }
}