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

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;

public class B244 {

    private static int n, q, treeSize;
    private static int[] b, minTree, maxTree;

    private static int createMinTree(int startIndex, int endIndex, int currentPos) {
        if (startIndex == endIndex) {
            return minTree[currentPos] = b[startIndex];
        }
        int mid = (startIndex + endIndex) / 2;
        return minTree[currentPos] = Math.min(createMinTree(startIndex, mid, currentPos * 2 + 1),
                createMinTree(mid + 1, endIndex, currentPos * 2 + 2));
    }

    private static int createMaxTree(int startIndex, int endIndex, int currentPos) {
        if (startIndex == endIndex) {
            return maxTree[currentPos] = b[startIndex];
        }
        int mid = (startIndex + endIndex) / 2;
        return maxTree[currentPos] = Math.max(createMaxTree(startIndex, mid, currentPos * 2 + 1),
                createMaxTree(mid + 1, endIndex, currentPos * 2 + 2));
    }

    private static int queryMinTree(int currentStartIndex, int currentEndIndex,
            int startQueryIndex, int endQueryIndex, int index) {
        if (startQueryIndex <= currentStartIndex && endQueryIndex >= currentEndIndex) {
            return minTree[index];
        }

        if (endQueryIndex < currentStartIndex || startQueryIndex > currentEndIndex) {
            return Integer.MAX_VALUE;
        }

        int mid = (currentStartIndex + currentEndIndex) / 2;
        return Math.min(queryMinTree(currentStartIndex, mid, startQueryIndex, endQueryIndex, index * 2 + 1),
                queryMinTree(mid + 1, currentEndIndex, startQueryIndex, endQueryIndex, index * 2 + 2));
    }

    private static int queryMaxTree(int currentStartIndex, int currentEndIndex,
            int startQueryIndex, int endQueryIndex, int index) {
        if (startQueryIndex <= currentStartIndex && endQueryIndex >= currentEndIndex) {
            return maxTree[index];
        }

        if (endQueryIndex < currentStartIndex || startQueryIndex > currentEndIndex) {
            return -1;
        }

        int mid = (currentStartIndex + currentEndIndex) / 2;
        return Math.max(queryMaxTree(currentStartIndex, mid, startQueryIndex, endQueryIndex, index * 2 + 1),
                queryMaxTree(mid + 1, currentEndIndex, startQueryIndex, endQueryIndex, index * 2 + 2));
    }

    private static int queryMax(int startIndex, int endIndex) {
        return queryMaxTree(0, n - 1, startIndex, endIndex, 0);
    }

    private static int queryMin(int startIndex, int endIndex) {
        return queryMinTree(0, n - 1, startIndex, endIndex, 0);
    }

    private static void createSegmentTree() {
        int heightOfTree = (int) Math.ceil(Math.log(n) / Math.log(2));
        treeSize = 2 * (int) Math.pow(2, heightOfTree) - 1;
        minTree = new int[treeSize];
        maxTree = new int[treeSize];
        createMinTree(0, n - 1, 0);
        createMaxTree(0, n - 1, 0);
    }

    public void solve() throws IOException {

        Scanner sc = new Scanner(System.in);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);


        int inp[] = getIntArray(br.readLine());
        n = inp[0];
        int t = inp[1];
        int c = inp[2];
        b = getIntArray(br.readLine());
        createSegmentTree();
        int startIndex, endIndex;
        int sum = 0;

        for (int i = 0; i <= n - c; i++) {
            int max = queryMax(i, i + c-1);
            //System.out.println(i+" "+(i+c-1)+"  max= "+max);
            if (max <= t) {
                sum++;
                //System.out.println("sum = "+sum);
            }
            
        }
        System.out.println(sum);
    }

    public static void main(String[] args) throws IOException {
        new B244().solve();

    }

    public static Integer toInt(String s) {
        return Integer.parseInt(s.trim());
    }
 

    public static int[] getIntArray(String line) {
        String s[] = line.split(" ");
        int a[] = new int[s.length];
        for (int i = 0; i < s.length; ++i) {
            a[i] = Integer.parseInt(s[i]);
        }
        return a;
    }

  
}
