#include <bits/stdc++.h>
using namespace std;
#define int long long
#define stoi stoll
using ll=long long;
using vi=vector<int>;
using pii=pair<int,int>;
#define ALL(c) begin(c),end(c)
#define RALL(c) rbegin(c),rend(c)
#define ITR(i,b,e) for(auto i=(b);i!=(e);++i)
#define FORE(x,c) for(auto &x:c)
#define REPF(i,a,n) for(int i=a,i##len=(int)(n);i<i##len;++i)
#define REP(i,n) REPF(i,0,n)
#define REPR(i,n) for(int i=(int)(n);i>=0;--i)
#define SZ(c) ((int)c.size())
#define CONTAIN(c,x) (c.find(x)!=end(c))
#define OUTOFRANGE(y,x,h,w) ((y)<0||(x)<0||(y)>=(h)||(x)>=(w))
#define dump(...)
const signed INF_=1001001001; const long long INF=1001001001001001001LL;
const int DX[9]={0,1,0,-1,1,1,-1,-1,0},DY[9]={-1,0,1,0,-1,1,1,-1,0};
template<class T> ostream& operator<<(ostream &os,const vector<T> &v) {
    ITR(i,begin(v),end(v))os<<*i<<(i==end(v)-1?"":" ");return os;}
template<class T> istream& operator>>(istream &is,vector<T> &v) {
    ITR(i,begin(v),end(v)) is>>*i;return is;}
template<class T,class U> istream& operator>>(istream &is, pair<T,U> &p) {
    is>>p.first>>p.second;return is;}
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> using heap=priority_queue<T,vector<T>,greater<T>>;
struct{template<class T> operator T(){T x;cin>>x;return x;}} IN;
struct before_main_function {
    before_main_function() {
        cin.tie(0);ios::sync_with_stdio(false);
        cout<<setprecision(15)<<fixed;
        #define endl "\n"
    }
} before_main_function;
//------------------8<------------------------------------8<--------------------

template <class T>
struct LazySegmentTree {
    using func = function<T(T, T)>;
    int size;
    vector<T> data;
    vector<T> lazy;
    vector<T> width;
    function<T(T, T, int)> updater;
    func merger, propagater;
    T ident_prop, ident_query;

    LazySegmentTree(int n, function<T(T, T, int)> update_func, func merge_func,
      func propagate_func, T identity_propagate, T identity_query)
      : updater(update_func), merger(merge_func), propagater(propagate_func),
      ident_prop(identity_propagate), ident_query(identity_query) {
        size = 1;
        while (size < n) size <<= 1;
        data.resize(size * 2, ident_query);
        lazy.resize(size * 2, ident_prop);
        width.resize(size * 2, 1);
        for (int i = size - 2; i >= 0; i--) {
            width[i] = width[i * 2 + 1] + width[i * 2 + 2];
        }
    }
    void lazy_propagate(int p) {
        data[p] = updater(data[p], lazy[p], width[p]);
        if (p < size-1) {
            lazy[p * 2 + 1] = propagater(lazy[p * 2 + 1], lazy[p]);
            lazy[p * 2 + 2] = propagater(lazy[p * 2 + 2], lazy[p]);
        }
        lazy[p] = ident_prop;
    }
    void update(int wishL, int wishR, int x, int watchL = 0, int watchR = -1, int k = 0) {
        if (watchR == -1) watchR = size;
        if (wishR <= watchL || watchR <= wishL) {
            lazy_propagate(k);
            return;
        }
        if (wishL <= watchL && watchR <= wishR) {
            lazy[k] = propagater(lazy[k], x);
            lazy_propagate(k);
            return;
        }

        int mid = (watchL + watchR) / 2;
        lazy_propagate(k);
        update(wishL, wishR, x, watchL, mid, k * 2 + 1);
        update(wishL, wishR, x, mid, watchR, k * 2 + 2);
        data[k] = merger(data[k * 2 + 1], data[k * 2 + 2]);
    }
    T query(int wishL, int wishR, int watchL = 0, int watchR = -1, int k = 0) {
        if (watchR == -1) watchR = size;
        if (watchR <= wishL || wishR <= watchL) return ident_query;
        if (wishL <= watchL && watchR <= wishR) {
            lazy_propagate(k);
            return data[k];
        }
        lazy_propagate(k);
        T ld = query(wishL, wishR, watchL, (watchL + watchR) / 2, k * 2 + 1);
        T rd = query(wishL, wishR, (watchL + watchR) / 2, watchR, k * 2 + 2);
        return merger(ld, rd);
    }
};

signed main() {
    int N, M, Q;
    cin >> N >> M >> Q;
    vector<vector<int>> q(M+Q);
    REP(i, M) {
        int d, a, b;
        cin >> d >> a >> b;
        q[i] = {d, 1, a, b};
    }
    REP(i, Q) {
        int e, s, t;
        cin >> e >> s >> t;
        q[M+i] = {e, 0, s, t, i};
    }
    sort(ALL(q));

    auto update = [](int a, int b, int w) {return a + b;};
    auto merge = [](int a, int b) {return min(a, b);};
    auto propagate = [](int a, int b) {return a + b;};
    LazySegmentTree<int> seg(N+1, update, merge, propagate, 0, INF);
    seg.update(0, N+1, -INF);

    vector<bool> ans(Q);
    REP(i, M+Q) {
        if (q[i][1] == 0) {
            int s = q[i][2], t = q[i][3], idx = q[i][4];
            if (s >= t) {
                ans[idx] = true;
            } else {
                ans[idx] = seg.query(s, t) > 0;
            }
        } else {
            int a = q[i][2], b = q[i][3];
            seg.update(a, b, 1);
        }
    }
    REP(i, Q) cout << (ans[i] ? "Yes" : "No") << endl;
    return 0;
}




Measured memory_bytes: 23284