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

public class triangularlogs_bowen3_AL {
  static final int MaxResultSize = 44;
  static int resultLength;
  static int[] result = new int[50];
  public static class Segtree {
    int[] rawValues;
    ArrayList<ArrayList<Integer>> values;
    public Segtree(int[] inputRawValues) {
      rawValues = inputRawValues;
      int n = rawValues.length;
      values = new ArrayList<ArrayList<Integer>>(4 * n);
      for (int i = 0; i < 4 * n; i++) values.add(new ArrayList<Integer>());
    }
    public void add(int k, int nl, int nr, int x, int v) {
      if(x < rawValues[nl] || x > rawValues[nr]) return;
      values.get(k).add(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 < values.get(k).size() && resultLength <= MaxResultSize; i++)
          result[resultLength++] = values.get(k).get(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;
    ArrayList<ArrayList<Integer>> childRawValues;
    int[] childRawValueCount;
    public Segtree2D(int[] inputRawValues) {
      rawValues = inputRawValues;
      int n = rawValues.length;
      trees = new Segtree[4 * n];
      childRawValues = new  ArrayList<ArrayList<Integer>>(4 * n);
      for (int i = 0; i < 4 * n; i++) childRawValues.add(new ArrayList<Integer>());
      childRawValueCount = new int[4 * n];
    }
    public void preAdd(int k, int nl, int nr, int x, int y) {
      if (x < rawValues[nl] || x > rawValues[nr]) return;
      childRawValues.get(k).add(y);
      if (x <= rawValues[nl] && rawValues[nr] <= x) return;
      int nm = (nl + nr) >> 1;
      preAdd(2*k+1, nl, nm, x, y);
      preAdd(2*k+2, nm+1, nr, x, y);
    }
    public void build(int k, int nl, int nr) {
      if (childRawValues.get(k).size() == 0) return;
      int[] childValues = unique(toArray(childRawValues.get(k)));
      childRawValueCount[k] = childValues.length;
      trees[k] = new Segtree(childValues);
      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 y, int v) {
      if (x < rawValues[nl] || x > rawValues[nr]) return;
      trees[k].add(0, 0, childRawValueCount[k] - 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, childRawValueCount[k] - 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.preAdd(0, 0, X - 1, xs[i], ys[i]);
    tr.build(0, 0, X - 1);
    //printTime("build 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;
  }

  public static int[] toArray(ArrayList<Integer> arr) {
    int[] values = new int[arr.size()];
    for (int i = 0; i < arr.size(); i++) values[i] = arr.get(i);
    return values;
  }
}

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());
  }
}