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.util.ArrayList;
import java.util.Scanner;
import java.math.*;


public class B_Prison_Transfer {

    public static void main(String[] args) {
        
        Scanner scan = new Scanner(System.in);
        String l = scan.nextLine();
        
        String[] r = l.split(" ");
        
//      BigInteger n = new BigInteger(""+Integer.parseInt(r[0])) ;
        int n = Integer.parseInt(r[0]);
        int t = Integer.parseInt(r[1]);
        int c = Integer.parseInt(r[2]);
        
        
        l = scan.nextLine();
        r  = l.split(" ");
        int [] s = new int[n];
        ArrayList indx = new ArrayList<Integer>();
        ArrayList tot = new ArrayList<Integer>();
        double count = 0;
        
        for (int i = 0; i < r.length; i++) {
            s[i] = Integer.parseInt(r[i]);
            if(s[i] > t){
                indx.add(i);
//              System.out.print(s[i]+" ");
            }
        }
        
        for (int i = 0; i < indx.size(); i++) {
            
            if(indx.size() == 1 && s.length!=1){
                tot.add(indx.get(i));
                
//              int v = (int) indx.get(i)- (int)indx.get(i-1);
//              tot.add(v-1);
                
                int v = (int) indx.get(i);
                tot.add(n-1-v);
                
            }
            else{
                if(i == 0){
                    tot.add(indx.get(i));
                }
                else if(i == indx.size()-1){
                    int v = (int) indx.get(i)- (int)indx.get(i-1);
                    tot.add(v-1);
                    
                    v = (int) indx.get(i);
                    tot.add(n-1-v);
                }
                
                else{
                    int v = (int) indx.get(i)- (int)indx.get(i-1);
                    tot.add(v-1);
                }
            }
        }


        
        if(tot.size() !=0){
            for (int i = 0; i < tot.size(); i++) {
                
                int p = (int) tot.get(i);
                if(p>=c){
                    count += p-c+1 ;
                }
                
            }
        }
        else{
            count =n-c+1;
        }
        System.out.println((int)count);
        
        
        
    }
//  
//  public static BigInteger combination(BigInteger n, BigInteger k)
//  {
//     if(n.compareTo(k) == 1){
//         return permutation(n).divide((permutation(k).multiply(permutation(n.subtract(k)))));
//     }
//     else if(n.compareTo(k) == 0){
//         return BigInteger.ONE;
//     }
//     else
//         return BigInteger.ZERO ;
//  }
//
//  public static BigInteger permutation(BigInteger i)
//  {
//      if (i.compareTo(BigInteger.ONE) == 0)
//      {
//          return BigInteger.ONE;
//      }
//      return i.multiply(permutation(i.subtract(BigInteger.ONE)));
//  }
}
