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>
#pragma comment(linker, "/STACK:102400000,102400000")
int _, cas;
using namespace std;
const int size = 510000, mod = 1000000, inf = 0x3f3f3f3f;
const long long llmod = 4294967296ll, llinf = 0x3f3f3f3f3f3f3f3fll;
const double pi = acos(-1.0), eps = 1e-8;
int month[2][13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
                    0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int nex[2][8] = {-1, 0, 1, 0, -1, 1, 1, -1, 0, 1, 0, -1, 1, 1, -1, -1};
template <class T>
inline void inc(T &a, T b) {
  a = (a + b) % mod;
}
template <class T>
inline T modu(T a) {
  return (a % mod + mod) % mod;
}
template <class T>
inline T modu(T a, T mod) {
  return (a % mod + mod) % mod;
}
template <class T>
inline void crl(T *l, T *r, int step) {
  T tmp = *l;
  for (T *i = l; i < r; i += step) *i = *(i + step);
  *(r - 1) = tmp;
}
template <class T>
inline void crr(T *l, T *r, int step) {
  T tmp = *(r - 1);
  for (T *i = r - 1; i > l; i -= step) *i = *(i - step);
  *l = tmp;
}
bool inline dbeq(double a, double b) { return fabs(a - b) < eps; }
template <class T>
inline void cmin(T &a, T b) {
  a = min(a, b);
}
template <class T>
inline void cmax(T &a, T b) {
  a = max(a, b);
}
inline int fastMax(int x, int y) {
  return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y;
}
inline int fastMin(int x, int y) {
  return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x;
}
int n, m, h, br[size], ar[size];
struct node {
  int a, b, c, len, f;
  node *l, *r;
} e[size * 4];
int last;
void init() { last = 0; }
void update(node *p) {
  node *l = p->l, *r = p->r;
  p->c = min(l->c, r->c);
}
void change(int c, node *p) {
  p->c += c;
  p->f += c;
}
void pushdown(node *p) {
  node *l = p->l, *r = p->r;
  if (p->len > 1 && p->f) {
    change(p->f, l), change(p->f, r);
  }
  p->f = 0;
}
node *build(int a, int b) {
  node *p = e + last++;
  p->a = a, p->b = b, p->len = b - a + 1, p->f = 0;
  if (a == b) {
    p->c = -a;
    return p;
  }
  int mid = a + b >> 1;
  p->l = build(a, mid);
  p->r = build(mid + 1, b);
  update(p);
  return p;
}
void modify(int a, int b, int c, node *p) {
  pushdown(p);
  if (p->a >= a && p->b <= b) {
    change(c, p);
    return;
  }
  int mid = p->a + p->b >> 1;
  if (a <= mid) modify(a, b, c, p->l);
  if (b > mid) modify(a, b, c, p->r);
  update(p);
}
int pos[size], ans;
int main() {
  cin >> n >> m >> h;
  for (int i = 1; i < m + 1; i++) cin >> br[i];
  sort(br + 1, br + 1 + m);
  for (int i = 1; i < n + 1; i++)
    cin >> ar[i], pos[i] = lower_bound(br + 1, br + 1 + m, h - ar[i]) - br;
  init();
  node *p = build(1, m);
  for (int i = m; i < n + 1; i++) {
    if (i == m) {
      for (int j = 1; j < m + 1; j++)
        if (pos[j] <= m) modify(pos[j], m, 1, p);
    } else {
      if (pos[i] <= m) modify(pos[i], m, 1, p);
      if (pos[i - m] <= m) modify(pos[i - m], m, -1, p);
    }
    ans += p->c >= 0;
  }
  cout << ans << endl;
  return 0;
}
