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/contest/1393/problem/B*/

import java.util.*;
import java.io.*;
import java.util.Arrays; 
import java.util.ArrayList; 
import java.util.Collections; 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.util.StringTokenizer;
import java.math.BigInteger;

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);

            HashMap<Integer, NumberWInd> hm = new HashMap<>();
            TreeSet<NumberWInd> ts = new TreeSet<>(new ComparatorByNumber());

            int count = 0;
            int start = 0;
            int end = c-1;
            
            //add first elements from array to form a contiguous segment
            for(int i = start; i <= end; i++) {
                int number = array[i];
                NumberWInd ni = new NumberWInd(i, number);
                hm.put(i, ni);
                ts.add(ni);
            }

            // check if contiguous segment is under requirements
            NumberWInd lastNi = ts.last();
            int number = lastNi.getNumber();
            if(number <= maxLimit) {
                count++;
            }

            //remove first element from ts and hm in order to add next elements and create the next contiguous segment
            NumberWInd firstNi = hm.get(start);
            ts.remove(firstNi);
            hm.remove(start);

            start++;
            end++;

            while(end < n) {
                NumberWInd ni = new NumberWInd(end, array[end]);
                hm.put(end, ni);
                ts.add(ni);
                lastNi = ts.last();
                number = lastNi.getNumber();
                if(number <= maxLimit) {
                    count++;
                }
                firstNi = hm.get(start);
                ts.remove(firstNi);
                hm.remove(start);
                start++;
                end++;
            }

            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;
    }
}