There are m people living in a city. There are n dishes sold in the city. Each dish i has a price p_i, a standard s_i and a beauty b_i. Each person j has an income of inc_j and a preferred beauty pref_j. 

A person would never buy a dish whose standard is less than the person's income. Also, a person can't afford a dish with a price greater than the income of the person. In other words, a person j can buy a dish i only if p_i ≤ inc_j ≤ s_i.

Also, a person j can buy a dish i, only if |b_i-pref_j| ≤ (inc_j-p_i). In other words, if the price of the dish is less than the person's income by k, the person will only allow the absolute difference of at most k between the beauty of the dish and his/her preferred beauty. 

Print the number of dishes that can be bought by each person in the city.

Input

The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5), the number of dishes available in the city and the number of people living in the city.

The second line contains n integers p_i (1 ≤ p_i ≤ 10^9), the price of each dish.

The third line contains n integers s_i (1 ≤ s_i ≤ 10^9), the standard of each dish.

The fourth line contains n integers b_i (1 ≤ b_i ≤ 10^9), the beauty of each dish.

The fifth line contains m integers inc_j (1 ≤ inc_j ≤ 10^9), the income of every person.

The sixth line contains m integers pref_j (1 ≤ pref_j ≤ 10^9), the preferred beauty of every person.

It is guaranteed that for all integers i from 1 to n, the following condition holds: p_i ≤ s_i.

Output

Print m integers, the number of dishes that can be bought by every person living in the city.

Examples

Input


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


Output


1 2 0 

Input


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


Output


0 2 3 

Note

In the first example, the first person can buy dish 2, the second person can buy dishes 1 and 2 and the third person can buy no dishes.

In the second example, the first person can buy no dishes, the second person can buy dishes 1 and 4, and the third person can buy dishes 1, 2 and 4.
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
  int v = 0, f = 1;
  char c = getchar();
  while (!isdigit(c) && c != '-') c = getchar();
  if (c == '-')
    f = -1;
  else
    v = v * 10 + c - '0';
  while (isdigit(c = getchar())) v = v * 10 + c - '0';
  x = v * f;
}
inline void read(long long &x) {
  long long v = 0ll, f = 1ll;
  char c = getchar();
  while (!isdigit(c) && c != '-') c = getchar();
  if (c == '-')
    f = -1;
  else
    v = v * 10 + c - '0';
  while (isdigit(c = getchar())) v = v * 10 + c - '0';
  x = v * f;
}
inline void readc(char &x) {
  char c;
  while ((c = getchar()) == ' ')
    ;
  x = c;
}
inline void writes(string s) { puts(s.c_str()); }
inline void writeln() { writes(""); }
inline void writei(int x) {
  if (x < 0) {
    putchar('-');
    x = abs(x);
  }
  if (!x) putchar('0');
  char a[25];
  int top = 0;
  while (x) {
    a[++top] = (x % 10) + '0';
    x /= 10;
  }
  while (top) {
    putchar(a[top]);
    top--;
  }
}
inline void writell(long long x) {
  if (x < 0) {
    putchar('-');
    x = abs(x);
  }
  if (!x) putchar('0');
  char a[25];
  int top = 0;
  while (x) {
    a[++top] = (x % 10) + '0';
    x /= 10;
  }
  while (top) {
    putchar(a[top]);
    top--;
  }
}
int n, m, i, j, s[800005], ans[200005];
struct ii {
  int l, r, lys, inc, pref, op;
} a[200005];
bool cmp(ii x, ii y) {
  if (x.op == 0 && y.op == 0) return x.r > y.r;
  if (x.op == 0 && y.op != 0) return x.r >= y.inc;
  if (x.op != 0 && y.op == 0) return x.inc > y.r;
  if (x.op != 0 && y.op != 0) return x.inc > y.inc;
}
struct query {
  int x, y, op;
};
vector<query> v;
vector<int> allx, ally;
void add(int x, int y) {
  int i;
  for (i = x; i; i -= (i & (-i))) s[i] += y;
}
int qry(int x) {
  int i, sss = 0;
  for (i = x; i <= 800000; i += (i & (-i))) sss += s[i];
  return sss;
}
void solve(const vector<query> &v, int l, int r) {
  if (v.empty()) return;
  if (l >= r) return;
  int mid = (l + r) / 2;
  vector<query> vl, vr;
  for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++) {
    if (it->x <= mid) {
      vl.push_back(*it);
      if (it->op == 0) add(it->y, 1);
    } else {
      vr.push_back(*it);
      if (it->op) ans[it->op] += qry(it->y);
    }
  }
  for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++) {
    if (it->x <= mid) {
      if (it->op == 0) add(it->y, -1);
    }
  }
  solve(vl, l, mid);
  solve(vr, mid + 1, r);
}
int main() {
  read(n);
  read(m);
  for (((i)) = (1); ((i)) <= ((n)); ((i))++) read(a[i].l);
  for (((i)) = (1); ((i)) <= ((n)); ((i))++) read(a[i].r);
  for (((i)) = (1); ((i)) <= ((n)); ((i))++) read(a[i].lys);
  for (((i)) = (1); ((i)) <= ((m)); ((i))++) read(a[i + n].inc);
  for (((i)) = (1); ((i)) <= ((m)); ((i))++) read(a[i + n].pref);
  for (((i)) = (1); ((i)) <= ((m)); ((i))++) a[i + n].op = i;
  stable_sort(a + 1, a + n + m + 1, cmp);
  for (((i)) = (1); ((i)) <= ((n + m)); ((i))++) {
    if (a[i].op) {
      v.push_back((query){a[i].pref + a[i].inc + 1 + 1,
                          a[i].pref - a[i].inc + 1000000001, a[i].op});
    } else {
      v.push_back(
          (query){a[i].lys + a[i].l + 1, a[i].lys - a[i].l + 1000000001, 0});
    }
  }
  for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++) {
    allx.push_back(it->x);
    ally.push_back(it->y);
  }
  stable_sort((allx).begin(), (allx).end());
  allx.resize(unique((allx).begin(), (allx).end()) - allx.begin());
  stable_sort((ally).begin(), (ally).end());
  ally.resize(unique((ally).begin(), (ally).end()) - ally.begin());
  for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++) {
    it->x = upper_bound((allx).begin(), (allx).end(), it->x) - allx.begin();
    it->y = upper_bound((ally).begin(), (ally).end(), it->y) - ally.begin();
  }
  solve(v, 1, allx.size());
  for (((i)) = (1); ((i)) <= ((m)); ((i))++) printf("%d ", ans[i]);
  return 0;
}
