#include <vector>
#pragma GCC target ("avx2")
#pragma GCC optimize ("O3")
#pragma GCC optimize ("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

template<typename T>
ostream_iterator<T> oit(const string &s = " "){ return ostream_iterator<T>(cout,s.c_str()); }
inline auto rep(int l, int r) { return views::iota(min(l, r), r); }
inline auto rep(int n) { return rep(0, n); }
inline auto rep1(int l, int r) { return rep(l, r + 1); }
inline auto rep1(int n) { return rep(1, n + 1); }
inline auto per(int l, int r) { return rep(l, r) | views::reverse; }
inline auto per(int n) { return per(0, n); }
inline auto per1(int l, int r) { return per(l, r + 1); }
inline auto per1(int n) { return per(1, n + 1); }
#define A(a) begin(a),end(a)
inline auto len = ranges::ssize;

struct chash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};
template<typename T, typename U> using pb_map = gp_hash_table<T, U, chash>;
template<typename T> using pb_set = gp_hash_table<T, null_type, chash>;
#define K first
#define V second

using ll = long long;
using ld = long double;

using vi = vector<int>;
using vii = vector<vector<int>>;
typedef vector<ll> vll;
using pll = pair<ll,ll>;
using pii = pair<int,int>;

template<bool HAS_QUERY, class B, class T, class F, class I>
struct wavelet_tree_base{
	int n, lg;
	B sigma;
	vector<vector<int>> data;
	vector<vector<T>> aggregate;
	F TT; // commutative group operation
	T T_id; // commutative group identity
	I Tinv; // commutative group inverse
	wavelet_tree_base(F TT, T T_id, I Tinv): TT(TT), T_id(T_id), Tinv(Tinv){ }
	wavelet_tree_base &operator=(const wavelet_tree_base &wt){
		n = wt.n;
		lg = wt.lg;
		sigma = wt.sigma;
		data = wt.data;
		return *this;
	}
	// O(n * log(sigma)) time and O(n * log(sigma)) memory
	void build(const vector<B> &key, B sigma){
		static_assert(!HAS_QUERY);
		assert(sigma > 0);
		for(auto x: key) assert(0 <= x && x < sigma);
		n = (int)key.size();
		this->sigma = sigma;
		lg = __lg(sigma) + (B(1) << lg != sigma) + 1;
		data.assign(lg, vector<int>(n + 1));
		vector<B> cur = key, next(n);
		for(auto h = lg; h --;){
			for(auto i = 0; i < n; ++ i) data[h][i + 1] = data[h][i] + (~cur[i] >> h & 1);
			array it{next.begin(), next.begin() + data[h][n]};
			for(auto i = 0; i < n; ++ i) *it[data[h][i] == data[h][i + 1]] ++ = cur[i];
			swap(cur, next);
		}
	}
	// O(n * log(sigma)) time and O(n * log(sigma)) memory
	template<class U>
	void build(const vector<B> &key, B sigma, const vector<U> &value){
		static_assert(HAS_QUERY);
		assert(sigma > 0);
		for(auto x: key) assert(0 <= x && x < sigma);
		n = (int)key.size();
		this->sigma = sigma;
		lg = __lg(sigma) + (B(1) << lg != sigma) + 1;
		data.assign(lg, vector<int>(n + 1));
		aggregate.assign(lg + 1, vector<T>(n + 1, T_id));
		vector<pair<B, T>> cur(n), next(n);
		for(auto i = 0; i < n; ++ i) cur[i] = {key[i], value[i]};
		for(auto h = lg; h --;){
			for(auto i = 0; i < n; ++ i) data[h][i + 1] = data[h][i] + (~cur[i].first >> h & 1);
			array it{next.begin(), next.begin() + data[h][n]};
			for(auto i = 0; i < n; ++ i){
				*it[data[h][i] == data[h][i + 1]] ++ = cur[i];
				aggregate[h + 1][i + 1] = data[h][i] == data[h][i + 1] ? aggregate[h + 1][i] : TT(aggregate[h + 1][i], cur[i].second);
			}
			swap(cur, next);
		}
		for(auto i = 0; i < n; ++ i) aggregate[0][i + 1] = TT(aggregate[0][i], cur[i].second);
	}
	// Returns the frequency of x in the interval [ql, qr)
	// O(log(sigma))
	int freq(int ql, int qr, int x) const{
		assert(0 <= ql && ql <= qr && qr <= n);
		assert(0 <= x);
		if(ql == qr || sigma <= x) return 0;
		for(auto h = lg; h --; ){
			if(~x >> h & 1) ql = data[h][ql], qr = data[h][qr];
			else ql += data[h][n] - data[h][ql], qr += data[h][n] - data[h][qr];
		}
		return qr - ql;
	}
	// Returns the frequency of x in the interval [ql, qr), along with the sum of their values
	// O(log(sigma))
	pair<int, T> freq_query(int ql, int qr, int x) const{
		static_assert(HAS_QUERY);
		assert(0 <= ql && ql <= qr && qr <= n);
		assert(0 <= x);
		if(ql == qr || sigma <= x) return {0, T_id};
		for(auto h = lg; h --; ){
			if(~x >> h & 1) ql = data[h][ql], qr = data[h][qr];
			else ql += data[h][n] - data[h][ql], qr += data[h][n] - data[h][qr];
		}
		return {qr - ql, TT(aggregate[0][qr], Tinv(aggregate[0][ql]))};
	}
	// Returns the number of occurrences of numbers in [0, xr) in the interval [ql, qr)
	// O(log(sigma))
	int count(int ql, int qr, B xr) const{
		assert(0 <= ql && ql <= qr && qr <= n);
		assert(0 <= xr);
		if(sigma <= xr) return qr - ql;
		if(xr == 0) return 0;
		int cnt = 0;
		for(auto h = lg; h --; ){
			if(~xr >> h & 1) ql = data[h][ql], qr = data[h][qr];
			else{
				cnt += data[h][qr] - data[h][ql];
				ql += data[h][n] - data[h][ql], qr += data[h][n] - data[h][qr];
			}
		}
		return cnt;
	}
	// Returns the number of occurrences of numbers in [0, xr) in the interval [ql, qr), along with the sum of their values
	// O(log(sigma))
	pair<int, T> count_query(int ql, int qr, B xr) const{
		static_assert(HAS_QUERY);
		assert(0 <= ql && ql <= qr && qr <= n);
		assert(0 <= xr);
		if(xr == 0) return {0, T_id};
		xr = min(sigma, xr);
		int cnt = 0;
		T sum = T_id;
		for(auto h = lg; h --; ){
			if(~xr >> h & 1) ql = data[h][ql], qr = data[h][qr];
			else{
				cnt += data[h][qr] - data[h][ql];
				sum = TT(sum, TT(aggregate[h + 1][qr], Tinv(aggregate[h + 1][ql])));
				ql += data[h][n] - data[h][ql], qr += data[h][n] - data[h][qr];
			}
		}
		return {cnt, sum};
	}
	// Returns the number of occurrences of numbers in [xl, xr) in the interval [ql, qr)
	// O(log(sigma))
	int count(int ql, int qr, B xl, B xr) const{
		assert(xl <= xr);
		if(xl == xr) return 0;
		return count(ql, qr, xr) - count(ql, qr, xl);
	}
	// Returns the number of occurrences of numbers in [xl, xr) in the interval [ql, qr), along with the sum of their values
	// O(log(sigma))
	pair<int, T> count_query(int ql, int qr, B xl, B xr) const{
		static_assert(HAS_QUERY);
		assert(xl <= xr);
		if(xl == xr) return {0, T_id};
		auto [lcnt, lsum] = count_query(ql, qr, xl);
		auto [rcnt, rsum] = count_query(ql, qr, xr);
		return {rcnt - lcnt, TT(rsum, Tinv(lsum))};
	}
	// Find the k-th smallest element in the interval [ql, qr), sigma if no such element
	// O(log(sigma))
	B find_by_order(int ql, int qr, int k) const{
		assert(0 <= k);
		if(k >= qr - ql) return sigma;
		B x = 0;
		for(auto h = lg; h --; ){
			if(k < data[h][qr] - data[h][ql]) ql = data[h][ql], qr = data[h][qr];
			else{
				k -= data[h][qr] - data[h][ql];
				x |= (B)1 << h;
				ql += data[h][n] - data[h][ql], qr += data[h][n] - data[h][qr];
			}
		}
		return x;
	}
	// Find the k-th smallest element in the interval [ql, qr), sigma if no such element, along with the sum of values of the k smallest elements (prioritizing smaller index)
	// O(log(sigma))
	pair<B, T> find_by_order_query(int ql, int qr, int k) const{
		assert(0 <= k);
		k = min(k, qr - ql);
		B x = 0;
		T sum = T_id;
		for(auto h = lg; h --; ){
			if(k < data[h][qr] - data[h][ql]) ql = data[h][ql], qr = data[h][qr];
			else {
				k -= data[h][qr] - data[h][ql];
				x |= (B)1 << h;
				sum = TT(sum, TT(aggregate[h + 1][qr], Tinv(aggregate[h + 1][ql])));
				ql += data[h][n] - data[h][ql], qr += data[h][n] - data[h][qr];
			}
		}
		return {x, TT(sum, TT(aggregate[0][ql + k], Tinv(aggregate[0][ql])))};
	}
	// Find the k-th smallest element in the interval [ql, qr) among elements >= xl, sigma if no such element
	// O(log(sigma))
	B find_by_order(int ql, int qr, B xl, int k) const{
		assert(0 <= ql && ql <= qr && qr <= n);
		assert(0 <= xl && 0 <= k);
		if(xl >= sigma) return sigma;
		k += count(ql, qr, 0, xl);
		if(k >= qr - ql) return sigma;
		return find_by_order(ql, qr, k);
	}
	// Find the k-th smallest element in the interval [ql, qr) among elements >= xl, sigma if no such element, along with the sum of values of the k smallest elements (prioritizing smaller index)
	// O(log(sigma))
	pair<B, T> find_by_order_query(int ql, int qr, B xl, int k) const{
		assert(0 <= ql && ql <= qr && qr <= n);
		assert(0 <= xl && 0 <= k);
		if(xl >= sigma) return {sigma, T_id};
		auto [cnt, sum] = count_query(ql, qr, 0, xl);
		k += cnt;
		auto [x, sum2] = find_by_order_query(ql, qr, k);
		return {x, TT(sum2, Tinv(sum))};
	}
	// Find the smallest element >= x, sigma if no such element
	// O(log(sigma))
	B lower_bound(int ql, int qr, B x) const{
		assert(0 <= x);
		return find_by_order(ql, qr, x, 0);
	}
	// Find the smallest element > x, sigma if no such element
	// O(log(sigma))
	B upper_bound(int ql, int qr, B x) const{
		assert(0 <= x);
		return find_by_order(ql, qr, x + 1, 0);
	}
	// Find the largest element <= x, -1 if no such element
	// O(log(sigma))
	B reverse_lower_bound(int ql, int qr, B x) const{
		assert(0 <= x);
		int cnt = count(ql, qr, x);
		return cnt ? find_by_order(ql, qr, cnt - 1) : -1;
	}
	// Find the largest element < x, -1 if no such element
	// O(log(sigma))
	B reverse_upper_bound(int ql, int qr, B x) const{
		assert(0 <= x);
		int cnt = count(ql, qr, x + 1);
		return cnt ? find_by_order(ql, qr, cnt - 1) : -1;
	}
};

template<class B>
auto make_wavelet_tree(){
	return wavelet_tree_base<false, B, int, plus<>, negate<>>(plus<>(), 0, negate<>());
}
// Supports query
template<class B, class T = long long, class F = plus<>, class I = negate<>>
auto make_Q_wavelet_tree(F TT = plus<>(), T T_id = 0, I Tinv = negate<>()){
	return wavelet_tree_base<true, B, T, F, I>(TT, T_id, Tinv);
}



struct Tree{int x,y,h;};
struct QR{int x1,y1,x2,y2;};
bool operator<(Tree t1,Tree t2){
    return t1.x<t2.x;
}

void run()
{
    int n,q; cin >> n >> q;

    vector<Tree> v(n);
    vector<QR> Q(q);

    set<int> st;
    for(int i : rep(n))
        cin >> v[i].x >> v[i].y >> v[i].h, st.insert(v[i].x);
    for(int i : rep(q))
        cin >> Q[i].x1 >> Q[i].y1 >> Q[i].x2 >> Q[i].y2, st.insert(Q[i].x1), st.insert(Q[i].x2);

    sort(A(v));
    // for(auto [x,y,h] : v)
    //     cout << x << " " << y << " " << h << endl;
    vll a(n),b(n),xarr(n);
    for(int i : rep(n)){
        a[i]=v[i].y;
        b[i]=v[i].h;
        xarr[i]=v[i].x;
    }

    auto wv = make_Q_wavelet_tree<ll>();
    wv.build(a,(ll)1e9,b);

    const int N = 50;
    for(auto [x1,y1,x2,y2] : Q){
        auto lb = ranges::lower_bound(xarr,x1);
        auto ub = ranges::upper_bound(xarr,x2);

        int l = lb-xarr.begin(),r=ub-xarr.begin();
        // cout << "\t\t" << l << " " << r << endl;
        // cout << "\t" << x1 << " " << x2 << endl;
        int cnt = wv.count(l,r,y1,y2+1);

        if(cnt>N)
            cout << "1\n";
        else{
            // Find the k-th smallest element in the interval [ql, qr) among elements >= xl, sigma if no such element, along with the sum of values of the k smallest elements (prioritizing smaller index)
	        // O(log(sigma))
            vll v;
            for(int i : rep(cnt)){
                auto res = wv.find_by_order_query(l,r,y1,i+1);
                v.push_back(res.second);
            }

            for(int i : per(1,len(v))) v[i] -= v[i-1];
            ranges::sort(v);

            bool good = false;
            for(int i : rep(2,len(v))){
                if(v[i]<v[i-1]+v[i-2]) {good=true;break;}
            }
            cout << good << "\n";
            // cout << "\t" << cnt << endl;
            // cout << "\t", ranges::copy(v,oit<ll>()),cout<<endl;
        }
    }
}

int main()
{
    //KING OF THE WORLD...... U.W.T.B
    cin.tie(0);
    ios_base::sync_with_stdio(false);
    run();
}