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

struct RMQ {
	using type = int;
	static type id() { return INT_MAX; }
	static type op(const type& l, const type& r) {
		return min(l, r);
	}
};

class seg_node {
public:
	using M = RMQ;
	using T = typename M::type;
	using U = int;

	T val;

private:
	bool flag;
	U lazy;

public:
	seg_node() : val(M::id()), flag(false) {}
	void init(const T& v) {
		val = v;
	}
	void init(const seg_node& l, const seg_node& r) {
		val = M::op(l.val, r.val);
	}
	void update(U v) {
		val = lazy = v;
		flag = true;
	}
	void push(seg_node& l, seg_node& r) {
		if (!flag) return;
		l.update(lazy);
		r.update(lazy);
		flag = false;
	}
	bool is_updated() const {
		return flag;
	}

};

class segment_tree {
	using M = typename seg_node::M;
	using T = typename seg_node::T;
	using U = typename seg_node::U;
	const int h, n;
	vector<seg_node> data;
	void init() {
		for (int i = n - 1; i >= 1; i--) {
			data[i].init(data[i << 1], data[(i << 1) | 1]);
		}
	}
	void push(int node) {
		data[node].push(data[node << 1], data[(node << 1) | 1]);
	}
	void update(int node) {
		data[node].val = M::op(data[node << 1].val, data[(node << 1) | 1].val);
	}
public:
	segment_tree(int n_)
		: h(ceil(log2(n_))), n(1 << h), data(n * 2) {}
	segment_tree(int n_, T v1)
		: h(ceil(log2(n_))), n(1 << h), data(n * 2) {
		for (int i = 0; i < n_; i++) {
			data[i + n].init(v1);
		}
		init();
	}
	segment_tree(const vector<T>& data_)
		: h(ceil(log2(data_.size()))), n(1 << h), data(n * 2) {
		for (int i = 0; i < (int)data_.size(); i++) {
			data[i + n].init(data_[i]);
		}
		init();
	}
	void update(int l, int r, U val) {
		l += n, r += n;
		for (int i = h; i > 0; i--) push(l >> i), push(r >> i);
		int tl = l, tr = r;
		r++;
		while (l < r) {
			if (l & 1) data[l++].update(val);
			if (r & 1) data[--r].update(val);
			l >>= 1; r >>= 1;
		}
		while (tl >>= 1, tr >>= 1, tl) {
			if (!data[tl].is_updated()) update(tl);
			if (!data[tr].is_updated()) update(tr);
		}
	}
	T find(int l, int r) {
		l += n, r += n;
		for (int i = h; i > 0; i--) push(l >> i), push(r >> i);
		r++;
		T res1 = M::id(), res2 = M::id();
		while (l < r) {
			if (l & 1) res1 = M::op(res1, data[l++].val);
			if (r & 1) res2 = M::op(data[--r].val, res2);
			l >>= 1; r >>= 1;
		}
		return M::op(res1, res2);
	}
};

int main()
{
	ios::sync_with_stdio(false), cin.tie(0);
	int N, M, Q;
	cin >> N >> M >> Q;
	vector<vector<int>> dab(M, vector<int>(3));
	vector<int> ds;
	for (int i = 0; i < M; i++) {
		cin >> dab[i][0] >> dab[i][1] >> dab[i][2]; dab[i][1]--, dab[i][2] -= 2;
		ds.push_back(dab[i][0]);
	}
	vector<int> res(Q);
	vector<vector<int>> est(Q, vector<int>(4));
	for (int i = 0; i < Q; i++) {
		cin >> est[i][0] >> est[i][1] >> est[i][2]; est[i][1]--, est[i][2] -= 2;
		est[i][3] = i;
		ds.push_back(est[i][0]);
	}
	sort(ds.begin(), ds.end());
	ds.erase(unique(ds.begin(), ds.end()), ds.end());
	sort(dab.begin(), dab.end());
	sort(est.begin(), est.end());
	int x = ds.size();
	segment_tree st(N);
	st.update(0, N - 1, 0);
	for (int i = 0, j = 0, k = 0; i < x; i++) {
		while (j < Q && est[j][0] <= ds[i]) {
			res[est[j][3]] = st.find(est[j][1], est[j][2]);
			j++;
		}
		while (k < M && dab[k][0] <= ds[i]) {
			st.update(dab[k][1], dab[k][2], 1);
			k++;
		}
	}
	for (int i = 0; i < Q; i++) {
		puts(res[i] ? "Yes" : "No");
	}
	return 0;
}


### Prompt

Please formulate a cpp solution to the following problem:

problem

AOR Co., Ltd. is a $ N $ story building. There is no basement floor.
AOR Ika-chan is a squid, so she can go down the stairs, but not up.

I decided to install $ M $ elevators in the building because it would be inconvenient if I couldn't climb upstairs.
It takes time to install the elevator, and the $ i $ th elevator will be installed the night after $ D_i $ and will be mobile on all floors above the $ A_i $ floor and below the $ B_i $ floor.

You were asked $ Q $ questions by AOR Ika-chan. The $ i $ th question is, "Can I move from the $ S_i $ floor to the $ T_i $ floor at noon $ E_i $ days later?"
The only means of transportation are stairs and elevators. In addition, the time required for movement shall be negligible.



input

$ N \ M \ Q $
$ D_1 \ A_1 \ B_1 $
$ \ vdots $
$ D_M \ A_M \ B_M $
$ E_1 \ S_1 \ T_1 $
$ \ vdots $
$ E_Q \ S_Q \ T_Q $

output

Print Yes or No on one line for each question. However, answer in the order in which they are asked. Also, output a line break at the end.

Example

Input

5 1 2
3 1 5
3 1 5
4 1 5


Output

No
Yes

### Response

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

struct RMQ {
	using type = int;
	static type id() { return INT_MAX; }
	static type op(const type& l, const type& r) {
		return min(l, r);
	}
};

class seg_node {
public:
	using M = RMQ;
	using T = typename M::type;
	using U = int;

	T val;

private:
	bool flag;
	U lazy;

public:
	seg_node() : val(M::id()), flag(false) {}
	void init(const T& v) {
		val = v;
	}
	void init(const seg_node& l, const seg_node& r) {
		val = M::op(l.val, r.val);
	}
	void update(U v) {
		val = lazy = v;
		flag = true;
	}
	void push(seg_node& l, seg_node& r) {
		if (!flag) return;
		l.update(lazy);
		r.update(lazy);
		flag = false;
	}
	bool is_updated() const {
		return flag;
	}

};

class segment_tree {
	using M = typename seg_node::M;
	using T = typename seg_node::T;
	using U = typename seg_node::U;
	const int h, n;
	vector<seg_node> data;
	void init() {
		for (int i = n - 1; i >= 1; i--) {
			data[i].init(data[i << 1], data[(i << 1) | 1]);
		}
	}
	void push(int node) {
		data[node].push(data[node << 1], data[(node << 1) | 1]);
	}
	void update(int node) {
		data[node].val = M::op(data[node << 1].val, data[(node << 1) | 1].val);
	}
public:
	segment_tree(int n_)
		: h(ceil(log2(n_))), n(1 << h), data(n * 2) {}
	segment_tree(int n_, T v1)
		: h(ceil(log2(n_))), n(1 << h), data(n * 2) {
		for (int i = 0; i < n_; i++) {
			data[i + n].init(v1);
		}
		init();
	}
	segment_tree(const vector<T>& data_)
		: h(ceil(log2(data_.size()))), n(1 << h), data(n * 2) {
		for (int i = 0; i < (int)data_.size(); i++) {
			data[i + n].init(data_[i]);
		}
		init();
	}
	void update(int l, int r, U val) {
		l += n, r += n;
		for (int i = h; i > 0; i--) push(l >> i), push(r >> i);
		int tl = l, tr = r;
		r++;
		while (l < r) {
			if (l & 1) data[l++].update(val);
			if (r & 1) data[--r].update(val);
			l >>= 1; r >>= 1;
		}
		while (tl >>= 1, tr >>= 1, tl) {
			if (!data[tl].is_updated()) update(tl);
			if (!data[tr].is_updated()) update(tr);
		}
	}
	T find(int l, int r) {
		l += n, r += n;
		for (int i = h; i > 0; i--) push(l >> i), push(r >> i);
		r++;
		T res1 = M::id(), res2 = M::id();
		while (l < r) {
			if (l & 1) res1 = M::op(res1, data[l++].val);
			if (r & 1) res2 = M::op(data[--r].val, res2);
			l >>= 1; r >>= 1;
		}
		return M::op(res1, res2);
	}
};

int main()
{
	ios::sync_with_stdio(false), cin.tie(0);
	int N, M, Q;
	cin >> N >> M >> Q;
	vector<vector<int>> dab(M, vector<int>(3));
	vector<int> ds;
	for (int i = 0; i < M; i++) {
		cin >> dab[i][0] >> dab[i][1] >> dab[i][2]; dab[i][1]--, dab[i][2] -= 2;
		ds.push_back(dab[i][0]);
	}
	vector<int> res(Q);
	vector<vector<int>> est(Q, vector<int>(4));
	for (int i = 0; i < Q; i++) {
		cin >> est[i][0] >> est[i][1] >> est[i][2]; est[i][1]--, est[i][2] -= 2;
		est[i][3] = i;
		ds.push_back(est[i][0]);
	}
	sort(ds.begin(), ds.end());
	ds.erase(unique(ds.begin(), ds.end()), ds.end());
	sort(dab.begin(), dab.end());
	sort(est.begin(), est.end());
	int x = ds.size();
	segment_tree st(N);
	st.update(0, N - 1, 0);
	for (int i = 0, j = 0, k = 0; i < x; i++) {
		while (j < Q && est[j][0] <= ds[i]) {
			res[est[j][3]] = st.find(est[j][1], est[j][2]);
			j++;
		}
		while (k < M && dab[k][0] <= ds[i]) {
			st.update(dab[k][1], dab[k][2], 1);
			k++;
		}
	}
	for (int i = 0; i < Q; i++) {
		puts(res[i] ? "Yes" : "No");
	}
	return 0;
}


```