#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;
const int MX = 1e9 + 3;
const int LM = 60;
const int C = (int)sqrt(N);

#define all(x) (x).begin(), (x).end()

struct Fenwick{
    int a[N];

    void add(int idx, int val){
        idx += 3;
        for(; idx < N; idx += idx & -idx)
            a[idx] += val;
    }
    int query(int idx){
        idx += 3;
        int ans = 0;
        for(; idx >= 1; idx -= idx & -idx)
            ans += a[idx];
        return ans;
    }
    int query(int l, int r){
        return query(r) - query(l - 1);
    }
};

int n, q;
array<int, 3> tree[N];
array<int, 5> quer[N];
bool ans[N];

vector<int> x, y;

set<int> s;
Fenwick st;

int query(int l, int r){
    if(l > r || r == -1 || l == n)
        return 0;
    if(st.query(l, r) > LM)
        return 1;

    auto it = s.lower_bound(l);
    vector<int> v;
    while(it != s.end() && *it <= r){
        v.push_back(tree[y[(*it)]][2]);
        ++it;
    }

    sort(all(v));
    for(int i = 0; i < (int)v.size() - 2; ++i)
        if(v[i] + v[i + 1] > v[i + 2])
            return true;
    return false;
}

void add(int idx){
    int j = tree[x[idx]][1];
    s.insert(j);
    st.add(j, 1);
}

void rem(int idx){
    int j = tree[x[idx]][1];
    s.erase(j);
    st.add(j, -1);
}

int lower_bound_x(const vector<int> &x, int val){
    int l = 0, r = n;
    while(l != r){
        int mid = (l + r) >> 1;
        if(tree[x[mid]][0] >= val)
            r = mid;
        else
            l = mid + 1;
    }
    return l;
}

int lower_bound_y(const vector<int> &y, int val){
    int l = 0, r = n;
    while(l != r){
        int mid = (l + r) >> 1;
        if(tree[y[mid]][1] >= val)
            r = mid;
        else
            l = mid + 1;
    }
    return l;
}

void compress(){
    
    for(int i = 0; i < n; ++i)
        x.push_back(i);

    sort(all(x), [&](auto l, auto r){
        return tree[l][0] < tree[r][0];
    });
   

    for(int i = 0; i < q; ++i){
        quer[i][0] = lower_bound_x(x, quer[i][0]);
        quer[i][2] = lower_bound_x(x, quer[i][2] + 1) - 1;
    }
     
    for(int i = 0; i < n; ++i)
        tree[x[i]][0] = i;

    
    for(int i = 0; i < n; ++i)
        y.push_back(i);

    sort(all(y), [&](auto l, auto r){
        return tree[l][1] < tree[r][1];
    });

    for(int i = 0; i < q; ++i){
        quer[i][1] = lower_bound_y(y, quer[i][1]);
        quer[i][3] = lower_bound_y(y, quer[i][3] + 1) - 1;
    }

    for(int i = 0; i < n; ++i)
        tree[y[i]][1] = i;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    cin >> n >> q;
    for(int i = 0; i < n; ++i)
        for(int j = 0; j < 3; ++j)
            cin >> tree[i][j];
    sort(tree, tree + n);

    for(int i = 0; i < q; ++i){
        for(int j = 0; j < 4; ++j)
            cin >> quer[i][j];
        quer[i][4] = i;
    }

    compress();

    sort(quer, quer + q, [&](auto l, auto r){
        if(l[0] / C == r[0] / C)
            return l[2] > r[2];
        return l[0] < r[0];
    });

    int l = 0, r = -1;
    for(int i = 0; i < q; ++i){
        if(quer[i][0] == n || quer[i][2] == -1){
            ans[quer[i][4]] = 0;
            continue;
        }
        for(; r < quer[i][2]; ++r)
            add(r + 1);
        for(; l > quer[i][0]; --l)
            add(l - 1);
        for(; r > quer[i][2]; --r)
            rem(r);
        for(; l < quer[i][0]; ++l)
            rem(l);

        ans[quer[i][4]] = query(quer[i][1], quer[i][3]);
    }

    for(int i = 0; i < q; ++i)
        cout << ans[i] << "\n";
}