Manao is solving a problem with the following statement:

<image>

He came up with a solution that produces the correct answers but is too slow. You are given the pseudocode of his solution, where the function getAnswer calculates the answer to the problem:
    
    
      
    getAnswer(a[1..n], b[1..len], h)  
      answer = 0  
      for i = 1 to n-len+1  
        answer = answer + f(a[i..i+len-1], b, h, 1)  
      return answer  
      
    f(s[1..len], b[1..len], h, index)  
      if index = len+1 then  
        return 1  
      for i = 1 to len  
        if s[index] + b[i] >= h  
          mem = b[i]  
          b[i] = 0  
          res = f(s, b, h, index + 1)  
          b[i] = mem  
          if res > 0  
            return 1  
      return 0  
    

Your task is to help Manao optimize his algorithm.

Input

The first line contains space-separated integers n, len and h (1 ≤ len ≤ n ≤ 150000; 1 ≤ h ≤ 109). The second line contains len space-separated integers b1, b2, ..., blen (1 ≤ bi ≤ 109). The third line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).

Output

Print a single number — the answer to Manao's problem.

Examples

Input

5 2 10
5 3
1 8 5 5 7


Output

2
#include <bits/stdc++.h>
using namespace std;
clock_t __stt;
inline void TStart() { __stt = clock(); }
inline void TReport() {
  printf("\nTaken Time : %.3lf sec\n",
         (double)(clock() - __stt) / CLOCKS_PER_SEC);
}
template <typename T>
T MIN(T a, T b) {
  return a < b ? a : b;
}
template <typename T>
T MAX(T a, T b) {
  return a > b ? a : b;
}
template <typename T>
T ABS(T a) {
  return a > 0 ? a : (-a);
}
template <typename T>
void UMIN(T &a, T b) {
  if (b < a) a = b;
}
template <typename T>
void UMAX(T &a, T b) {
  if (b > a) a = b;
}
int n, m, h, a[150005], b[150005];
namespace segT {
int add[600005], mn[600005];
void init(int p, int L = 0, int R = m - 1) {
  add[p] = 0;
  if (L == R) {
    mn[p] = -m + L;
  } else {
    int M = ((L + R) >> 1);
    init((p << 1), L, M);
    init(((p << 1) | 1), M + 1, R);
    mn[p] = MIN(mn[p << 1], mn[(p << 1) | 1]);
  }
}
void push(int p, int L = 0, int R = m - 1) {
  mn[p] += add[p];
  if (L < R) {
    add[p << 1] += add[p];
    add[(p << 1) | 1] += add[p];
  }
  add[p] = 0;
}
void modify(int p, int v, int r, int L = 0, int R = m - 1) {
  if (r < 0) return;
  if (R <= r) {
    add[p] += v;
    push(p, L, R);
    return;
  }
  push(p, L, R);
  int M = ((L + R) >> 1);
  modify((p << 1), v, r, L, M);
  if (r > M)
    modify(((p << 1) | 1), v, r, M + 1, R);
  else
    push(((p << 1) | 1), M + 1, R);
  mn[p] = MIN(mn[p << 1], mn[(p << 1) | 1]);
}
int query() {
  push(1);
  return mn[1];
}
};  // namespace segT
int gv(int v) { return upper_bound(b, b + m, v) - b - 1; }
int main() {
  int i, j, k, res;
  scanf("%d%d%d", &n, &m, &h);
  for (i = 0; i < m; ++i) {
    scanf("%d", b + i);
    b[i] = h - b[i];
  }
  for (i = 0; i < n; ++i) scanf("%d", a + i);
  segT::init(1);
  sort(b, b + m);
  for (i = n - m; i < n; ++i) {
    segT::modify(1, 1, gv(a[i]));
  }
  res = (segT::query() >= 0);
  for (i = n - m - 1; i >= 0; --i) {
    segT::modify(1, -1, gv(a[i + m]));
    segT::modify(1, 1, gv(a[i]));
    res += (int)(segT::query() >= 0);
  }
  printf("%d\n", res);
  return 0;
}
