#include <bits/stdc++.h>
using namespace std;
int n, m, q;
template <typename Monoid, typename OperatorMonoid = Monoid>
struct LazySegmentTree {
  using F = function<Monoid(Monoid, Monoid)>;
  using G = function<Monoid(Monoid, OperatorMonoid)>;
  using H = function<OperatorMonoid(OperatorMonoid, OperatorMonoid)>;
  using P = function<OperatorMonoid(OperatorMonoid, int)>;
  int sz;
  vector<Monoid> data;
  vector<OperatorMonoid> lazy;
  const F f;
  const G g;
  const H h;
  const P p;
  const Monoid M1;
  const OperatorMonoid OM0;
  LazySegmentTree(int n, const F f, const G g, const H h, const P p,
                  const Monoid &M1, const OperatorMonoid OM0)
      : f(f), g(g), h(h), p(p), M1(M1), OM0(OM0) {
    sz = 1;
    while (sz < n) sz <<= 1;
    data.assign(2 * sz, M1);
    lazy.assign(2 * sz, OM0);
  }
  void set(int k, const Monoid &x) { data[k + sz] = x; }
  void build() {
    for (int k = sz - 1; k > 0; k--) {
      data[k] = f(data[2 * k + 0], data[2 * k + 1]);
    }
  }
  void propagate(int k, int len) {
    if (lazy[k] != OM0) {
      if (k < sz) {
        lazy[2 * k + 0] = h(lazy[2 * k + 0], lazy[k]);
        lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
      }
      data[k] = g(data[k], p(lazy[k], len));
      lazy[k] = OM0;
    }
  }
  Monoid update(int a, int b, const OperatorMonoid &x, int k, int l, int r) {
    propagate(k, r - l);
    if (r <= a || b <= l) {
      return data[k];
    } else if (a <= l && r <= b) {
      lazy[k] = h(lazy[k], x);
      propagate(k, r - l);
      return data[k];
    } else {
      return data[k] = f(update(a, b, x, 2 * k + 0, l, (l + r) >> 1),
                         update(a, b, x, 2 * k + 1, (l + r) >> 1, r));
    }
  }
  Monoid update(int a, int b, const OperatorMonoid &x) {
    return update(a, b, x, 1, 0, sz);
  }
  Monoid query(int a, int b, int k, int l, int r) {
    propagate(k, r - l);
    if (r <= a || b <= l) {
      return M1;
    } else if (a <= l && r <= b) {
      return data[k];
    } else {
      return f(query(a, b, 2 * k + 0, l, (l + r) >> 1),
               query(a, b, 2 * k + 1, (l + r) >> 1, r));
    }
  }
  Monoid query(int a, int b) { return query(a, b, 1, 0, sz); }
  Monoid operator[](const int &k) { return query(k, k + 1); }
};
int main() {
  cin >> n >> m >> q;
  vector<pair<int, pair<int, int>>> D(m), E(q);
  for (auto &i : D) cin >> i.first >> i.second.first >> i.second.second;
  for (auto &i : E) cin >> i.first >> i.second.first >> i.second.second;
  map<pair<int, pair<int, int>>, int> ma;
  for (int i = 0; i < q; ++i) {
    if (E[i].second.first > E[i].second.second)
      swap(E[i].second.first, E[i].second.second);
    ma[E[i]] = i;
  }
  sort(D.begin(), D.end());
  sort(E.begin(), E.end());
  auto f = [](int a, int b) { return min(a, b); };
  auto g = [](int a, int b) { return a + b; };
  auto h = [](int a, int b) { return a + b; };
  auto p = [](int a, int b) { return a; };
  LazySegmentTree<int> seg(2 * n + 3, f, g, h, p, 1001001001, 0);
  seg.update(0, 2 * n + 3, -1001001001);
  vector<int> ans(q);
  int idx = 0;
  for (int i = 0; i < q; ++i) {
    pair<int, pair<int, int>> p = E[i];
    while (idx < m && D[idx].first < p.first) {
      pair<int, int> r = D[idx].second;
      seg.update(2 * r.first, 2 * r.second + 1, 1);
      idx++;
    }
    ans[ma[p]] = seg.query(2 * p.second.first, 2 * p.second.second + 1);
  }
  for (int i = 0; i < q; ++i) {
    cout << (ans[i] ? "Yes" : "No") << endl;
  }
}
