The prison of your city has n prisoners. As the prison can't accommodate all of them, the city mayor has decided to transfer c of the prisoners to a prison located in another city.

For this reason, he made the n prisoners to stand in a line, with a number written on their chests. The number is the severity of the crime he/she has committed. The greater the number, the more severe his/her crime was.

Then, the mayor told you to choose the c prisoners, who will be transferred to the other prison. He also imposed two conditions. They are,

  * The chosen c prisoners has to form a contiguous segment of prisoners. 
  * Any of the chosen prisoner's crime level should not be greater then t. Because, that will make the prisoner a severe criminal and the mayor doesn't want to take the risk of his running away during the transfer. 



Find the number of ways you can choose the c prisoners.

Input

The first line of input will contain three space separated integers n (1 ≤ n ≤ 2·105), t (0 ≤ t ≤ 109) and c (1 ≤ c ≤ n). The next line will contain n space separated integers, the ith integer is the severity ith prisoner's crime. The value of crime severities will be non-negative and will not exceed 109. 

Output

Print a single integer — the number of ways you can choose the c prisoners.

Examples

Input

4 3 3
2 3 1 1


Output

2


Input

1 1 1
2


Output

0


Input

11 4 2
2 2 0 7 3 2 2 4 9 1 4


Output

6
/* Solution for:https://codeforces.com/problemset/problem/427/B*/
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class Main {

  public static void main(String[] args) {
    try (PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out))) {
      FastScanner in = new FastScanner(System.in);
      int n = in.nextInt();
      int maxLimit = in.nextInt();
      int c = in.nextInt();
      int[] array = in.nextIntArray(n);

      TreeSet<NumberWind> ts = new TreeSet<>(new ComparatorByNumber());
      int count = 0;
      for (int i = 0; i < n; i++) {
        ts.add(new NumberWind(i, array[i]));

        if (i < c - 1) { // Alternatively: if (ts.size() < c)
          // Keep adding while the window is not big enough
          continue;
        }

        // Window is filled, check if it's OK
        NumberWind lastNi = ts.last();
        if (lastNi.getNumber() <= maxLimit) {
          count++;
        }

        // Now remove the element that falls off the window;
        int indexToRemove = i - (c - 1);
        ts.remove(new NumberWind(indexToRemove, array[indexToRemove]));
      }

      out.println(count);

    } finally {
      // out.close();
    }
  }
}

class ComparatorByNumber implements Comparator<NumberWind> {
  @Override
  public int compare(NumberWind a, NumberWind b) {
    if (a.getNumber() != b.getNumber()) {
      return a.getNumber() - b.getNumber();
    }
    return a.getIndex() - b.getIndex();
  }
}

class NumberWind {
  private final int number;
  private final int index;

  NumberWind(int index, int number) {
    this.number = number;
    this.index = index;
  }

  public int getIndex() {
    return this.index;
  }

  public int getNumber() {
    return this.number;
  }

  public String toString() {
    return "index: " + index + " " + "number: " + number;
  }

  @Override
  public boolean equals(Object numberWind) {
    if (numberWind instanceof NumberWind) {
      final NumberWind ni = (NumberWind) numberWind;
      if (this == ni) {
        return true;
      } else if (this.number == ni.getNumber() && this.index == ni.getIndex()) {
        return true;
      }
    }
    return false;
  }

  public int hashCode() {
    return index * 5 + number;
  }
}

class FastScanner {
  private final BufferedReader br;
  private StringTokenizer st;

  FastScanner(InputStream inputStream) {
    br = new BufferedReader(new InputStreamReader(inputStream));
  }

  String next() {
    while (st == null || !st.hasMoreTokens()) {
      try {
        st = new StringTokenizer(br.readLine());
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
    return st.nextToken();
  }

  int nextInt() {
    return Integer.parseInt(next());
  }

  char nextChar() {
    return (next()).charAt(0);
  }

  long nextLong() {
    return Long.parseLong(next());
  }

  double nextDouble() {
    return Double.parseDouble(next());
  }

  ArrayList<Integer> nextIntList(int count) {
    ArrayList<Integer> array = new ArrayList<>();
    for (int n = 0; n < count; n++) {
      int number = nextInt();
      array.add(number);
    }
    return array;
  }

  int[] nextIntArray(int count) {
    int[] array = new int[count];
    for (int n = 0; n < count; n++) {
      array[n] = nextInt();
    }
    return array;
  }
}
