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;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
  if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
  if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
  char c, sg = 0;
  while (c = getchar(), (c > '9' || c < '0') && c != '-')
    ;
  for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
       c = getchar())
    first = (first << 1) + (first << 3) + c - '0';
  if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
  gn(first);
  gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
  gn(first);
  gn(second);
  gn(z);
}
template <typename T>
inline void print(T first) {
  if (first < 0) {
    putchar('-');
    return print(-first);
  }
  if (first < 10) {
    putchar('0' + first);
    return;
  }
  print(first / 10);
  putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
  print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
  print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
  printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
  printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
  for (; b; b >>= 1, a = (long long)a * a % m)
    if (b & 1) ans = (long long)ans * a % m;
  return ans;
}
int n, m, h;
int a[150010], b[150010], ans;
int mn[600010], flag[600010];
void push_up(int u) { mn[u] = min(mn[(u << 1)], mn[((u << 1) | 1)]); }
void build(int u, int L, int R) {
  if (L + 1 == R) {
    mn[u] = L - n;
    return;
  }
  build((u << 1), L, (L + R >> 1));
  build(((u << 1) | 1), (L + R >> 1), R);
  push_up(u);
}
void update(int u, int first) {
  mn[u] += first;
  flag[u] += first;
}
void push_down(int u) {
  if (flag[u]) {
    update((u << 1), flag[u]);
    update(((u << 1) | 1), flag[u]);
    flag[u] = 0;
  }
}
void update(int u, int L, int R, int l, int r, int first) {
  if (L >= r || R <= l) return;
  if (L >= l && R <= r) {
    update(u, first);
    return;
  }
  push_down(u);
  update((u << 1), L, (L + R >> 1), l, r, first);
  update(((u << 1) | 1), (L + R >> 1), R, l, r, first);
  push_up(u);
}
int main() {
  gn(m, n, h);
  for (int i = 0; i < n; i++) {
    gn(b[i]);
    b[i] = h - b[i];
  }
  sort(b, b + n);
  for (int i = 0; i < m; i++) {
    gn(a[i]);
    a[i] = upper_bound(b, b + n, a[i]) - b;
  }
  build(1, 0, n);
  for (int i = 0, j = 0; i + n - 1 < m; i++) {
    while (j < i + n) {
      if (a[j] > 0) update(1, 0, n, 0, a[j], 1);
      j++;
    }
    if (mn[1] >= 0) ans++;
    if (a[i] > 0) update(1, 0, n, 0, a[i], -1);
  }
  println(ans);
}
