import java.io.*;
import java.util.*;

public class triangularlogs_bowen3 {
  static final int MaxResultSize = 44;
  static int resultLength;
  static int[] result = new int[50];
  public static class Segtree {
    int[] rawValues;
    int[][] vals;
    int[] valCount;
    public Segtree(int[] inputRawValues) {
      rawValues = inputRawValues;
      int n = rawValues.length;
      valCount = new int[4 * n];
      vals = new int[4 * n][];
    }
    public void preAdd(int k, int nl, int nr, int x) {
      if(x < rawValues[nl] || x > rawValues[nr]) return;
      valCount[k]++;
      if (nl == nr) return;
      int nm = (nl + nr) >> 1;
      preAdd(2*k+1, nl, nm, x);
      preAdd(2*k+2, nm+1, nr, x);
    }
    public void build(int k, int nl, int nr) {
      vals[k] = new int[valCount[k]];
      valCount[k] = 0;
      if (nl == nr) return;
      int nm = (nl + nr) >> 1;
      build(2*k+1, nl, nm);
      build(2*k+2, nm+1, nr);
    }
    public void add(int k, int nl, int nr, int x, int v) {
      if(x < rawValues[nl] || x > rawValues[nr]) return;
      vals[k][valCount[k]++] = v;
      if (nl == nr) return;
      int nm = (nl + nr) >> 1;
      add(2*k+1, nl, nm, x, v);
      add(2*k+2, nm+1, nr, x, v);
    }
    public void get(int k, int nl, int nr, int l, int r) {
      if(r < rawValues[nl] || l > rawValues[nr] || resultLength > MaxResultSize) return;
      if(l <= rawValues[nl] && rawValues[nr] <= r) {
        for (int i = 0; i < vals[k].length && resultLength <= MaxResultSize; i++)
          result[resultLength++] = vals[k][i];
        return;
      }
      int nm = (nl + nr) >> 1;
      get(2*k+1, nl, nm, l, r);
      get(2*k+2, nm+1, nr, l, r);
    }
  }

  static long startTime = System.currentTimeMillis();
  private static void printTime(String msg) {
    long curTime = System.currentTimeMillis();
    System.err.println(msg + " " + (curTime - startTime) + "ms");
    startTime = curTime;
  }

  public static class Segtree2D {
    Segtree[] trees;
    int[] rawValues;
    int[] childRawValueCount;
    int[][] childRawValues;
    public Segtree2D(int[] inputRawValues) {
      rawValues = inputRawValues;
      int n = rawValues.length;
      trees = new Segtree[4 * n];
      childRawValueCount = new int[4 * n];
      childRawValues = new int[4 * n][];
    }
    public void preAdd1(int k, int nl, int nr, int xl, int xr) {
      if (xr < rawValues[nl] || xl > rawValues[nr]) return;
      childRawValueCount[k]++;
      if (xl <= rawValues[nl] && rawValues[nr] <= xr) return;
      int nm = (nl + nr) >> 1;
      preAdd1(2*k+1, nl, nm, xl, xr);
      preAdd1(2*k+2, nm+1, nr, xl, xr);
    }
    public void build1(int k, int nl, int nr) {
      childRawValues[k] = new int[childRawValueCount[k]];
      childRawValueCount[k] = 0;
      if (nl == nr) return;
      int nm = (nl + nr) >> 1;
      build1(2*k+1, nl, nm);
      build1(2*k+2, nm+1, nr);
    }
    public void preAdd2(int k, int nl, int nr, int x, int y) {
      if (x < rawValues[nl] || x > rawValues[nr]) return;
      childRawValues[k][childRawValueCount[k]++] = y;
      if (x <= rawValues[nl] && rawValues[nr] <= x) return;
      int nm = (nl + nr) >> 1;
      preAdd2(2*k+1, nl, nm, x, y);
      preAdd2(2*k+2, nm+1, nr, x, y);
    }
    public void build2(int k, int nl, int nr) {
      if (childRawValues[k].length == 0) return;
      childRawValues[k] = unique(childRawValues[k]);
      trees[k] = new Segtree(childRawValues[k]);
      if (nl == nr) return;
      int nm = (nl + nr) >> 1;
      build2(2*k+1, nl, nm);
      build2(2*k+2, nm+1, nr);
    }
    public void preAdd3(int k, int nl, int nr, int x, int y) {
      if (x < rawValues[nl] || x > rawValues[nr]) return;
      trees[k].preAdd(0, 0, childRawValues[k].length - 1, y);
      if (nl == nr) return;
      int nm = (nl + nr) >> 1;
      preAdd3(2*k+1, nl, nm, x, y);
      preAdd3(2*k+2, nm+1, nr, x, y);
    }
    public void build3(int k, int nl, int nr) {
      if (childRawValues[k].length == 0) return;
      trees[k].build(0, 0, childRawValues[k].length - 1);
      if (nl == nr) return;
      int nm = (nl + nr) >> 1;
      build3(2*k+1, nl, nm);
      build3(2*k+2, nm+1, nr);
    }
    public void add(int k, int nl, int nr, int x, int y, int v) {
      if (x < rawValues[nl] || x > rawValues[nr]) return;
      trees[k].add(0, 0, childRawValues[k].length - 1, y, v);
      if (nl == nr) return;
      int nm = (nl + nr) >> 1;
      add(2*k+1, nl, nm, x, y, v);
      add(2*k+2, nm+1, nr, x, y, v);
    }
    public void get(int k, int nl, int nr, int xl, int xr, int yl, int yr) {
      if(xr < rawValues[nl] || xl > rawValues[nr] || resultLength > MaxResultSize) return;
      if(xl <= rawValues[nl] && rawValues[nr] <= xr) {
        if (trees[k] != null) trees[k].get(0, 0, childRawValues[k].length - 1, yl, yr);
        return;
      }
      int nm = (nl + nr) >> 1;
      get(2*k+1, nl, nm, xl, xr, yl, yr);
      get(2*k+2, nm+1, nr, xl, xr, yl, yr);
    }
  }
  public static void main(String[] args) throws IOException {
    InputReader in = new InputReader(new InputStreamReader(System.in));
    int n = in.nextInt(), q = in.nextInt();
    int[] xValues = new int[n + 2 * q];
    int X = 0;
    int[] xs = new int[n];
    int[] ys = new int[n];
    int[] hs = new int[n];
    for (int i = 0; i < n; i++) {
      xs[i] = in.nextInt();
      ys[i] = in.nextInt();
      hs[i] = in.nextInt();
      xValues[X++] = xs[i];
    }
    int[] xlows = new int[q];
    int[] xhighs = new int[q];
    int[] ylows = new int[q];
    int[] yhighs = new int[q];
    for (int i = 0; i < q; i++) {
      xlows[i] = in.nextInt();
      ylows[i] = in.nextInt();
      xhighs[i] = in.nextInt();
      yhighs[i] = in.nextInt();
      xValues[X++] = xlows[i];
      xValues[X++] = xhighs[i];
    }
    xValues = unique(xValues);
    X = xValues.length;

    Segtree2D tr = new Segtree2D(xValues);
    for (int i = 0; i < n; i++) tr.preAdd1(0, 0, X - 1, xs[i], xs[i]);
    tr.build1(0, 0, X - 1);
    // printTime("build1 done");

    for (int i = 0; i < n; i++) tr.preAdd2(0, 0, X - 1, xs[i], ys[i]);
    tr.build2(0, 0, X - 1);
    // printTime("build2 done");

    for (int i = 0; i < n; i++) tr.preAdd3(0, 0, X - 1, xs[i], ys[i]);
    tr.build3(0, 0, X - 1);
    // printTime("build3 done");

    for (int i = 0; i < n; i++) tr.add(0, 0, X - 1, xs[i], ys[i], hs[i]);
    // printTime("added to tree");

    for (int i = 0; i < q; i++) {
      resultLength = 0;
      tr.get(0, 0, X - 1, xlows[i], xhighs[i], ylows[i], yhighs[i]);
      int ans = resultLength > MaxResultSize ? 1 : 0;
      if (ans == 0) {
        Arrays.sort(result, 0, resultLength);
        for (int j = 2; j < resultLength; j++)
          if ((long)result[j - 2] + result[j - 1] > result[j]) {
            ans = 1;
            break;
          }
      }
      System.out.println(ans);
    }
  }

  public static int[] unique(int[] values) {
    Arrays.sort(values);
    int L = 1;
    for (int i = 1; i < values.length; i++) {
      if (values[i] != values[i - 1]) values[L++] = values[i];
    }
    int[] result = new int[L];
    for (int i = 0; i < L; i++) result[i] = values[i];
    return result;
  }
}

class InputReader {
  BufferedReader br;
  StringTokenizer st;

  InputReader(InputStreamReader in) {
    br = new BufferedReader(in);
  }

  String next() {
    while (st == null || !st.hasMoreTokens()) {
      try {
        st = new StringTokenizer(br.readLine());
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    return st.nextToken();
  }

  int nextInt() {
    return Integer.parseInt(next());
  }
}