#include <bits/stdc++.h>
using namespace std;

#define fs first
#define sc second

const int inf = 1001001001;

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);
  }
};

string Yes = "Yes", No = "No";

int main() {
  int n, m, q;
  cin >> n >> m >> q;

  using ei13333 = tuple<int, int, int, int>;
  vector<ei13333> query;

  for (int i = 0; i < m; ++i) {
    int d, a, b;
    cin >> d >> a >> b;

    query.push_back(ei13333(d, inf, a, b));
  }

  for (int i = 0; i < q; ++i) {
    int e, s, t;
    cin >> e >> s >> t;
    query.push_back(ei13333(e, i, s, t));
  }

  sort(query.begin(), query.end());

  vector<string> ans(q);
  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 + 1, f, g, h, p, inf, 0);
  seg.update(0, 2 * n + 1, -inf);

  for (int i = 0; i < query.size(); ++i) {
    int d, type, a, b;
    tie(d, type, a, b) = query[i];

    if (type == inf) {
      seg.update(2 * a - 1, 2 * b, 1);
    } else {
      ans[type] = (seg.query(2 * a - 1, 2 * b) ? Yes : No);
    }
  }

  for (auto &i : ans) cout << i << endl;
}



Measured memory_bytes: 11096