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·10^5), t (0 ≤ t ≤ 10^9) and c (1 ≤ c ≤ n). The next line will contain n space separated integers, the i^{th} integer is the severity i^{th} prisoner's crime. The value of crime severities will be non-negative and will not exceed 10^9. 


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

Difficulty: EASY

Solutions:
(n, t, c) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
ans = 0
amount = 0
for i in a:
	if i <= t:
		amount += 1
	elif i > t:
		if amount >= c:
			ans += amount - c + 1
		amount = 0
if amount >= c:
	ans += amount - c + 1
print(ans)


def main():
	(n, t, c) = map(int, input().split())
	a = list(map(int, input().split()))
	count = 0
	pris_grp = 0
	for i in range(c):
		if a[i] > t:
			count += 1
	if count == 0:
		pris_grp += 1
	for i in range(c, n):
		if a[i - c] > t:
			count -= 1
		if a[i] > t:
			count += 1
		if count == 0:
			pris_grp += 1
	print(pris_grp)
main()


(n, t, c) = [int(i) for i in input().split()]
h = [int(i) for i in input().split()]
res = 0
cnt = 0
for i in h:
	if i > t:
		cnt = 0
	else:
		cnt += 1
	if cnt >= c:
		res += 1
print(res)


(n, t, c) = map(int, input().strip().split())
arr = list(map(int, input().strip().split()))
all_seq = []
curr_seq = []
for i in arr:
	if i > t:
		if len(curr_seq) > 0:
			all_seq.append(len(curr_seq))
			curr_seq = []
	else:
		curr_seq.append(i)
if len(curr_seq) > 0:
	all_seq.append(len(curr_seq))
counter = 0
for i in all_seq:
	counter += max(0, i - c + 1)
print(counter)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
s = [0 for i in a]
h = 0
l = 0

def push(i):
	nonlocal h, l, s, a
	while h < l and a[s[l - 1]] <= a[i]:
		l -= 1
	s[l] = i
	l += 1
for i in range(c):
	if a[i] > t:
		push(i)
if h == l:
	ans = 1
else:
	ans = 0
for i in range(c, n):
	if h < l and i - c == s[h]:
		h += 1
	if a[i] > t:
		push(i)
	if h == l:
		ans += 1
print(ans)


(n, t, c) = map(int, input().split())
line = list(map(int, input().split()))
line.append(t + 1)
start = -1
ans = 0
for i in range(n + 1):
	if line[i] > t:
		if i - start - 1 >= c:
			ans += i - start - c
		start = i
print(ans)


(z, zz) = (input, lambda : list(map(int, z().split())))
fast = lambda : stdin.readline().strip()
zzz = lambda : [int(i) for i in fast().split()]
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2 or x == 0:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = 1
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
(n, t, c) = zz()
lst = zzz()
ans = []
lenth = 0
for i in lst:
	if i > t:
		if lenth <= 0:
			continue
		ans.append(lenth)
		lenth = 0
		continue
	lenth += 1
ans.append(lenth)
res = 0
for i in ans:
	res += max(0, i - c + 1)
print(res)


(n, t, c) = map(int, input().split())
prisoners = list(map(int, input().split()))
stack = []
ans = 0
for p in prisoners:
	if p <= t:
		stack.append(p)
		if len(stack) == c:
			ans += 1
			stack.pop()
	else:
		stack = []
print(ans)


(n, t, c) = map(int, input().split())
l = list(map(int, input().split()))
ans = 0
count = 0
for i in range(n):
	if l[i] <= t:
		count += 1
	else:
		count = 0
	if count >= c:
		ans += 1
print(ans)


import sys
import math
(n, t, c) = [int(x) for x in sys.stdin.readline().split()]
ni = [int(x) for x in sys.stdin.readline().split()]
k = 0
res = 0
for i in range(n):
	if ni[i] > t:
		if k - c >= 0:
			res += k - c + 1
		k = 0
	else:
		k += 1
if k - c >= 0:
	res += k - c + 1
print(res)


inp = input().split()
n = int(inp[0])
t = int(inp[1])
c = int(inp[2])
pris = list(map(int, input().split()))
last = -1
ans = 0
for i in range(n + 1):
	if i == n or pris[i] > t:
		ans += max(0, i - last - c)
		last = i
print(ans)


(n, t, c) = map(int, input().split())
ll = list(map(int, input().split())) + [t + 2]
sposob = 0
kol = [0] * (n + 1)
l = 0
for i in ll:
	if i <= t:
		l += 1
	else:
		kol[l] += 1
		l = 0
for i in range(c, n + 1):
	if kol[i] > 0:
		sposob += kol[i] * (i - c + 1)
print(sposob)


(n, t, c) = map(int, input().split())
x = list(map(int, input().split()))
goodpos = []
for i in range(n):
	if x[i] <= t:
		goodpos.append(i)
lens = []
streak = 1
for i in range(1, len(goodpos)):
	if goodpos[i] == goodpos[i - 1] + 1:
		streak += 1
	else:
		lens.append(streak)
		streak = 1
lens.append(streak)
if goodpos == []:
	lens = []
tot = 0
for i in lens:
	tot += max(i - c + 1, 0)
print(tot)


from collections import deque
(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
cur_max = -1
left_to_right = deque()
right_to_left = deque()
for i in range(n):
	if i % c == 0:
		cur_max = a[i]
		left_to_right.append(cur_max)
	else:
		if a[i] > cur_max:
			cur_max = a[i]
		left_to_right.append(cur_max)
cur_max = -1
for i in range(n - 1, -1, -1):
	if cur_max == -1 or i % c == c - 1:
		cur_max = a[i]
		right_to_left.appendleft(cur_max)
	else:
		if a[i] > cur_max:
			cur_max = a[i]
		right_to_left.appendleft(cur_max)
for i in range(n - c + 1):
	if max(right_to_left[i], left_to_right[i + c - 1]) <= t:
		ans += 1
print(ans)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
b = [-1]
res = 0
tmp = 0
for i in range(n):
	if a[i] > t:
		b.append(i)
b.append(n)
for i in range(1, len(b)):
	tmp = b[i] - b[i - 1] - 1
	res += max(tmp - c + 1, 0)
print(res)


(n, t, c) = map(int, input().split())
arr = list(map(int, input().split()))
count = 0
ans = 0
for x in arr:
	if x <= t:
		count += 1
	else:
		temp = count - c + 1
		if temp < 0:
			temp = 0
		ans += temp
		count = 0
temp = count - c + 1
if temp < 0:
	temp = 0
print(ans + temp)


(n, t, c) = [int(x) for x in input().split()]
prisoners = [int(x) for x in input().split()]
more_than_t = [0]
for i in range(n):
	if prisoners[i] > t:
		more_than_t.append(i + 1)
more_than_t.append(n + 1)
i = 0
result = 0
while i < len(more_than_t) - 1:
	diff = more_than_t[i + 1] - more_than_t[i] - 1
	if diff >= c:
		result += diff - c + 1
	i += 1
print(result)


def get_ans():
	(n, t, c) = map(int, input().split())
	l = list(map(int, input().split()))
	st = 0
	en = 0
	ans = 0
	for (idx, i) in enumerate(l):
		if i > t:
			en = idx - 1
			if en < st:
				st = idx + 1
				continue
			else:
				ll = en - st + 1
				if ll < c:
					st = idx + 1
					continue
				else:
					st = idx + 1
					ans += ll - c + 1
		if idx == len(l) - 1:
			if i <= t:
				en = idx
				ll = en - st + 1
				if c <= ll:
					ans += ll - c + 1
	print(ans)
get_ans()


def inp():
	return map(int, input().split())

def arr_inp():
	return [int(x) for x in input().split()]
(n, t, c) = inp()
a = arr_inp()
(p1, p2, count, ans) = (0, 0, 1, 0)
while p2 < n:
	if a[p2] <= t:
		if count == c:
			ans += 1
			p1 += 1
		else:
			count += 1
		p2 += 1
	else:
		p2 += 1
		p1 = p2
		count = 1
print(ans)


import math
import sys
import collections

def getdict(n):
	d = {}
	if type(n) is list:
		for i in n:
			if i in d:
				d[i] += 1
			else:
				d[i] = 1
	else:
		for i in range(n):
			t = ii()
			if t in d:
				d[t] += 1
			else:
				d[t] = 1
	return d

def cdiv(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)
(n, t, c) = mi()
d = li()
r = q = 0
for i in d:
	if i > t:
		q = 0
	else:
		q += 1
		if q == c:
			(r, q) = (r + 1, q - 1)
print(r)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
count = 0
start = 0
i = 0
co = 0
while i < n:
	if a[i] <= t:
		co += 1
	else:
		co = 0
	if co >= c:
		count += 1
	i += 1
print(count)


(n, t, c) = [int(x) for x in input().split()]
prisoners = [int(x) for x in input().split()]
result = 0
temp = 0
for i in range(n + 1):
	if i < n and prisoners[i] <= t:
		temp += 1
	elif temp >= c:
		result += temp - c + 1
		temp = 0
	else:
		temp = 0
print(result)


(n, t, c) = map(int, input().split())
l = [-1 if int(i) > t else int(i) for i in input().split()]
x = 0
ans = 0
for i in range(len(l)):
	if not l[i] is -1:
		x += 1
	else:
		p = x - c + 1
		if p < 0:
			x = 0
			continue
		else:
			ans += p
			x = 0
r = x - c + 1
if r < 0:
	print(ans)
else:
	print(ans + r)


(n, dng, bus) = map(int, input().split())
l = list(map(int, input().split())) + [10 ** 9 + 1]
res = 0
cont = 0
for i in l:
	if i <= dng:
		cont += 1
	else:
		if cont >= bus:
			a = cont - bus + 1
			res += a
		cont = 0
print(res)


import sys
(n, t, c) = map(int, sys.stdin.readline().split())
an = list(map(int, sys.stdin.readline().split()))
ans = 0
pre = -1
for i in range(n + 1):
	if i == n or (i < n and an[i] > t):
		cnt = i - pre - 1
		pre = i
		if cnt >= c:
			ans += cnt - c + 1
print(ans)


(n, t, c) = map(int, input().split())
x = list(map(int, input().split()))
b = 0
e = 0
p = 0
while b < n:
	if x[b] <= t:
		e += 1
		if e >= c:
			p += 1
	else:
		e = 0
	b += 1
print(p)


(n, t, c) = map(int, input().split())
plist = list(map(int, input().split()))
a = ans = 0
for i in range(n):
	if plist[i] <= t:
		a += 1
	else:
		if a >= c:
			ans += a - c + 1
		a = 0
if a >= c:
	ans += a - c + 1
print(ans)


def solve(total, t, req, p):
	p.append(None)
	pointer_a = 0
	pointer_b = 1
	ans = 0
	while pointer_a <= total - req:
		if p[pointer_a] > t:
			pointer_a = pointer_b
			pointer_b += 1
			continue
		elif p[pointer_b] == None:
			pass
		elif p[pointer_b] <= t:
			pass
		elif pointer_b - pointer_a + 1 <= req:
			pointer_a = pointer_b + 1
			pointer_b += 2
			continue
		if pointer_b - pointer_a + 1 >= req:
			ans += 1
			pointer_a += 1
			pointer_b += 1
		else:
			pointer_b += 1
	return ans
(total, t, c) = list(map(int, input().split()))
p = list(map(int, input().split()))
print(solve(total, t, c, p))


import sys
(n, t, c) = map(int, sys.stdin.readline().split())
a = list(map(int, sys.stdin.readline().split()))
beg = 0
end = 0
ans = 0
for i in range(n):
	if a[i] > t:
		if end == i - 1:
			ans += max(end - beg - c + 2, 0)
		beg = i + 1
		end = i + 1
	elif i == n - 1:
		ans += max(n - beg - c + 1, 0)
	else:
		end = i
print(ans)


(n, t, c) = [int(x) for x in input().split()]
crime = [int(x) for x in input().split()]
count = 0
res = 0
for x in crime:
	if x <= t:
		count += 1
	else:
		if count >= c:
			res += count - c + 1
		count = 0
if count >= c:
	res += count - c + 1
print(res)


in1 = tuple(map(lambda x: int(x), input().split()))
prisoners = list(map(lambda x: int(x), input().split()))
n = in1[0]
t = in1[1]
c = in1[2]
count = 0
l = []
prisoners.append(float('inf'))
for p in prisoners:
	if p <= t:
		count += 1
	else:
		l.append(count)
		count = 0
l = list(filter(lambda x: x >= c, l))
result = 0
for value in l:
	result = result + value - c + 1
print(result)


def main():
	(n, t, c) = [int(c) for c in input().split()]
	s = ''.join([str(int(int(c) <= t)) for c in input().split()])
	s = s.split('0')
	res = 0
	for e in s:
		if len(e) >= c:
			res += len(e) - c + 1
	print(res)
main()


(n, t, c) = input().split(' ')
(n, t, c) = (int(n), int(t), int(c))
a = [int(x) for x in input().split(' ')]
j = 0
m = 0
for i in range(0, len(a)):
	if a[i] <= t:
		j += 1
	elif a[i] > t:
		j = 0
	if j >= c:
		m += 1
print(m)


from math import ceil
(n, t, c) = [int(x) for x in input().split()]
prisoners = [int(x) for x in input().split()]
segments = []
segments.append(0)
for i in range(n):
	if prisoners[i] > t:
		segments.append(i + 1)
segments.append(n + 1)
total = 0
for i in range(1, len(segments)):
	total += segments[i] - segments[i - 1] - c if segments[i] - segments[i - 1] > c else 0
print(total)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
summ = 0
count = 0
for i in range(n):
	if a[i] <= t:
		count += 1
	else:
		if count >= c:
			summ += count - c + 1
		count = 0
if count >= c:
	summ += count - c + 1
print(summ)


(numPrisoners, maxSeverity, choiceLenght) = tuple(map(int, input().split(' ')))
prisoners = list(map(int, input().split(' ')))
threats_index = [-1]
for i in range(len(prisoners)):
	if prisoners[i] > maxSeverity:
		threats_index += [i]
threats_index += [len(prisoners)]
choicePossibilities = 0
for i in range(len(threats_index) - 1):
	interval = threats_index[i + 1] - threats_index[i] - 1
	if interval >= choiceLenght:
		choicePossibilities += interval - choiceLenght + 1
print(choicePossibilities)


a = input().split(' ')
a = [int(x) for x in a]
(n, t, c) = (a[0], a[1], a[2])
prisoners = input().split()
prisoners = [int(x) for x in prisoners]
d = []
ctr = 0
for x in prisoners:
	if x <= t:
		ctr += 1
	else:
		d.append(ctr - c + 1)
		ctr = 0
d.append(ctr - c + 1)
d = [x for x in d if x > 0]
print(sum(d))


(n, t, c) = map(int, input().split())
(k, s) = (c - 1, 0)
for (i, j) in enumerate(map(int, input().split())):
	if j > t:
		s += max(0, i - k)
		k = i + c
print(s + max(0, n - k))


def fun():
	s = input().split()
	n = int(s[0])
	t = int(s[1])
	l = int(s[2])
	arr = input().split()
	count = 0
	les = 0
	a = [-1]
	for i in range(n):
		if int(arr[i]) > t:
			a.append(i)
	a.append(n)
	for i in range(1, len(a), 1):
		diff = a[i] - a[i - 1] - 1
		count += max(diff - l + 1, 0)
	print(count)
fun()


(n, t, c) = map(int, input().split())
lis = [int(x) for x in input().split()]
ans = 0
cnt = 0
for i in lis:
	if i <= t:
		cnt += 1
	else:
		cnt = 0
	if cnt >= c:
		ans += 1
print(ans)


def solve(n, t, c, prisoners):
	(ans, temp) = (0, 0)
	for i in range(n):
		if prisoners[i] <= t:
			temp += 1
		else:
			if temp >= c:
				ans += temp - c + 1
			temp = 0
	if temp >= c:
		ans += temp - c + 1
	return ans
(n, t, c) = map(int, input().split(' '))
prisoners = list(map(int, input().split(' ')))
print(solve(n, t, c, prisoners))


(n, t, c) = map(int, input().split())
ps = list(map(int, input().split()))
s = [0] + [i + 1 for i in range(n) if ps[i] > t] + [n + 1]
print(sum((s[i] - s[i - 1] - c for i in range(1, len(s)) if s[i] - s[i - 1] > c)))


(n, t, c) = map(int, input().split())
x = 0
z = 0
b = []
for i in map(int, input().split()):
	if i <= t:
		x += 1
	else:
		x = 0
	if x >= c:
		z += 1
print(z)


(n, t, c) = map(int, input().split())
val = v = 0
for i in input().split():
	if int(i) > t:
		v = 0
	else:
		v = v + 1
	if v >= c:
		val = val + 1
print(val)


(prisonNum, crimeStd, chooseNum) = map(int, input().split())
crimeLv = list(map(int, input().split()))
newList = []
prev = 0
for i in range(prisonNum):
	if crimeLv[i] > crimeStd:
		if prev == i:
			prev = i + 1
		else:
			newList.append(crimeLv[prev:i])
			prev = i + 1
if prev <= prisonNum - 1:
	newList.append(crimeLv[prev:prisonNum])
count = 0
for crimeList in newList:
	if len(crimeList) < chooseNum:
		continue
	elif len(crimeList) == chooseNum:
		count += 1
		continue
	else:
		count += len(crimeList) - chooseNum + 1
print(count)


(n, t, c) = map(int, input().split())
seq = list(map(int, input().split()))
(start, end) = (0, 0)
res = 0
for i in range(n):
	if seq[i] <= t:
		if end - start + 1 == c:
			start += 1
			res += 1
		end += 1
	else:
		(start, end) = (i, i)
print(res)


(n, t, c) = input().split()
n = int(n)
t = int(t)
c = int(c)
ans = 0
k = 0
for i in input().split():
	if int(i) <= t:
		k += 1
	else:
		k = 0
	if k >= c:
		ans += 1
print(ans)


(n, t, e) = map(int, input().split())
c = list(map(int, input().split()))
w = 0
for y in range(n):
	if c[y] > t:
		c[y] = ' '
	else:
		c[y] = 'x'
for z in ''.join(c).split():
	w += max(0, len(z) - e + 1)
print(w)


(N, t, c) = map(int, input().strip().split())
A = list(map(int, input().strip().split()))
N = len(A)
ans = 0
cont = 0
for i in range(N):
	if A[i] <= t:
		cont += 1
	else:
		cont = 0
	if cont >= c:
		ans += 1
print(ans)


R = lambda : map(int, input().split())
(n, t, c) = R()
p = list(R())
m = 0
i = 0
l = 0
while i < n:
	x = p[i]
	if x > t:
		l = i + 1
	elif i - l + 1 == c:
		m += 1
		l += 1
	i += 1
print(m)


import copy
import sys
from collections import defaultdict, Counter

def input():
	return sys.stdin.readline()

def mapi():
	return map(int, input().split())

def maps():
	return map(str, input().split())

def print(arg, *argv, sep='', end=None):
	sys.stdout.write(str(arg))
	for i in argv:
		sys.stdout.write(sep + str(i)) if sep else sys.stdout.write(' ' + str(i))
	sys.stdout.write(end) if end else sys.stdout.write('\n')

def GCD(x, y):
	return GCD(y, x % y) if y else x

def modPow(x, y, p):
	(res, x) = (1, x % p)
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		(y, x) = (y >> 1, x * x % p)
	return res

def modInv(s, mod):
	return modPow(s, mod - 2, mod)

def solve():
	t = 1
	while t:
		t -= 1
		(n, x, c) = mapi()
		a = list(mapi())
		res = 0
		cnt = 0
		for i in range(n):
			if a[i] <= x:
				cnt += 1
			else:
				if cnt >= c:
					res += cnt - c + 1
				cnt = 0
		if cnt >= c:
			res += cnt - c + 1
		print(res)
solve()


(n, t, c) = map(int, input().split())
A = list(map(int, input().split()))
numIn = 0
for i in range(c):
	if A[i] > t:
		numIn += 1
ans = 0
r = c
while r < n:
	if numIn == 0:
		ans += 1
	if A[r - c] > t:
		numIn -= 1
	if A[r] > t:
		numIn += 1
	r += 1
if numIn == 0:
	ans += 1
print(ans)


(n, t, c) = map(int, input().split())
arr = list(map(int, input().strip().split()))
i = 0
k = 0
res = 0
while i < n:
	if arr[i] <= t:
		k += 1
	else:
		k = 0
	if k >= c:
		res += 1
	i += 1
print(res)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
i = 0
j = 0
ans = 0
for k in range(len(a)):
	if a[k] > t:
		if j - i >= c:
			ans += j - i - c + 1
		i = k + 1
		j = k + 1
	else:
		j += 1
if j - i >= c:
	ans += j - i - c + 1
print(ans)


(n, t, c) = map(int, input().split())
prisoners = list(map(int, input().split()))
start = 0
end = 0
result = 0
for end in range(len(prisoners)):
	if prisoners[end] > t:
		length = end - start
		if length >= c:
			result += length - c + 1
		start = end + 1
if end - start + 1 >= c:
	result += end - start - c + 2
print(result)


(n, t, c) = map(int, input().split())
Arr = [int(_) for _ in input().split()]
excount = 0
if c == 1:
	for item in Arr:
		if item <= t:
			excount += 1
	print(excount)
elif len(set(Arr)) == 1 and Arr[0] > t:
	print('0')
else:
	i = 0
	count = 0
	while Arr[i] > t:
		i += 1
	j = i + 1
	while j < n and i <= j:
		if Arr[j] > t:
			j += 1
			i = j
		elif (j - i + 1) % c == 0 and Arr[j] <= t and (Arr[i] <= t):
			count += 1
			i += 1
			j += 1
		else:
			j += 1
	print(count)


(n, t, c) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
pref = [0]
for i in range(n):
	if a[i] > t:
		pref.append(pref[-1] + 1)
	else:
		pref.append(pref[-1])
cnt = 0
for i in range(n - c + 1):
	if pref[i] == pref[i + c]:
		cnt += 1
print(cnt)


(n, t, c) = map(int, input().split())
l = list(map(int, input().split()))
s = [0] * n
for i in range(n):
	s[i] = l[i] > t
ans = 0
k = 0
for i in range(n):
	if s[i] == 0:
		k += 1
	else:
		ans += max(k - c + 1, 0)
		k = 0
print(ans + max(k - c + 1, 0))


(n, t, c) = map(int, input().split())
p = [int(i) for i in input().split()]
i = 0
ch = 0
while i < n:
	if p[i] > t:
		i += 1
	else:
		l = 0
		j = i
		while j < n and p[j] <= t:
			l += 1
			j += 1
		if l >= c:
			ch += l - c + 1
		i = j
print(ch)


(n, t, c) = map(int, input().split())
l = [int(x) for x in input().split()]
a = 0
b = 0
for i in range(n):
	if l[i] > t:
		if a >= c:
			b += a - c + 1
		a = 0
	else:
		a += 1
if a >= c:
	b += a - c + 1
print(b)


(n, t, c) = tuple(map(int, input().split()))
s = list(map(int, input().split()))
k = 0
i = 0
j = 0
while i < n:
	if s[i] > t:
		j = 0
	else:
		j += 1
		if j >= c:
			k += 1
	i += 1
print(k)


import sys
(n, t, c) = map(int, input().split(' ', 3))
v = [int(x) for x in input().split()]
i = 0
sol = 0
cnt = 0
while i < len(v):
	if v[i] <= t:
		cnt += 1
	else:
		cnt = 0
	if cnt >= c:
		sol += 1
	i += 1
print(sol)


def main():
	(n, t, c) = map(int, input().split())
	l = list(map(int, input().split()))
	cnt = sum((_ > t for _ in l[:c]))
	res = int(not cnt)
	for (a, b) in zip(l, l[c:]):
		cnt += (b > t) - (a > t)
		if not cnt:
			res += 1
	print(res)
main()


(n, t, c) = map(int, input().split())
k = 0
s = 0
for i in list(map(int, input().split())):
	if i <= t:
		k += 1
		if k >= c:
			s += 1
	else:
		k = 0
print(s)


(n, t, c) = map(int, input().split())
s = list(map(int, input().split()))
curr = 0
l = []
ch = 0
for i in range(n):
	if s[i] > t:
		if i == n - 1:
			ch = 1
		l.append(i - curr)
		curr = i + 1
if ch == 0:
	l.append(n - curr)
ans = 0
for i in range(len(l)):
	if l[i] - c + 1 > 0:
		ans += l[i] - c + 1
print(ans)


(n, t, c) = map(int, input().split())
(x, y) = (0, 0)
a = list(map(int, input().split()))
for i in a:
	if i <= t:
		x += 1
	else:
		x = 0
	if x >= c:
		y += 1
print(y)


(n, t, c) = list(map(int, input().split()))
lista = list(map(int, input().split()))
segments = []
cont = 0
for i in lista:
	if i <= t:
		cont += 1
	else:
		segments.append(cont)
		cont = 0
if cont != 0:
	segments.append(cont)
	cont = 0
res = 0
for i in segments:
	if i >= c:
		res += i - c + 1
print(res)


import sys

def __starting_point():
	(n, t, c) = list(map(int, sys.stdin.readline().split()))
	prisoners = list(map(int, sys.stdin.readline().split()))
	cnt = 0
	risk = 0
	for i in range(c):
		if t < prisoners[i]:
			risk += 1
	if not risk:
		cnt += 1
	for i in range(c, n):
		if t < prisoners[i]:
			risk += 1
		if t < prisoners[i - c]:
			risk -= 1
		if not risk:
			cnt += 1
	print(cnt)
__starting_point()


(n, t, c) = (int(i) for i in input().split())
ctr = 0
ans = 0
for i in input().split():
	a = int(i)
	if a > t:
		ctr = 0
	else:
		ctr += 1
		if ctr >= c:
			ans += 1
print(ans)


(n, t, c) = [int(i) for i in input().split()]
crime = [1 if int(i) <= t else 0 for i in input().split()]
sta = 0
ans = 0
for i in crime:
	if i == 0:
		sta = 0
	else:
		sta += 1
	if sta >= c:
		ans += 1
print(ans)


(n, t, c) = map(int, input().split())
l = list(map(int, input().split()))
x = 0
s = 0
for i in range(n):
	if l[i] <= t:
		x += 1
	else:
		if x >= c:
			s += x - c + 1
		x = 0
if x >= c:
	s += x - c + 1
print(s)


(n, t, c) = map(int, input().split())
Array = list(map(int, input().split()))
windowSize = c
Count1 = 0
Count2 = 0
for i in range(n):
	if Array[i] <= t:
		Count1 = Count1 + 1
	else:
		Count1 = 0
	if Count1 >= c:
		Count2 = Count2 + 1
print(Count2)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
cnt = 0
l = 0
i = 0
while i < len(a):
	while i < len(a) and a[i] <= t:
		i += 1
	L = i - l
	if L >= c:
		cnt += L - c + 1
	i += 1
	l = i
print(cnt)


import bisect
import collections
import copy
import functools
import heapq
import itertools
import math
import random
import re
import sys
import time
import string
from typing import List
sys.setrecursionlimit(99999)
(n, t, c) = map(int, sys.stdin.readline().split())
arr = list(map(int, sys.stdin.readline().split()))
dp = [0] * n
if arr[0] <= t:
	dp[0] = 1
for i in range(1, n):
	if arr[i] <= t:
		dp[i] = dp[i - 1] + 1
print(sum((x >= c for x in dp)))


(n, m, k) = map(int, input().split())
c = list(map(int, input().split()))
l = 0
x = 0
for i in range(n):
	if c[i] <= m:
		x += 1
		if x >= k:
			l += 1
	else:
		x = 0
print(l)


from sys import stdin, stdout
from math import factorial as f
inp = stdin.readline
op = stdout.write
(n, t, c) = list(map(int, inp().split()))
dp = []
a = list(map(int, inp().split()))
temp = 0
for i in range(n):
	if a[i] <= t:
		temp = temp + 1
	else:
		dp.append(temp)
		temp = 0
dp.append(temp)
sums = 0
n = len(dp)
for i in range(n):
	temp = dp[i]
	if c <= temp:
		sums = sums + (temp - c + 1)
op(str(sums))


(n, limit, c) = map(int, input().split())
listn = list(map(int, input().split()))
res = 0
prev = -1
i = 0
while i < n:
	if listn[i] > limit:
		res += max(i - prev - c, 0)
		prev = i
	i += 1
res += max(n - prev - c, 0)
print(res)


(n, t, c) = map(int, input().split())
arr = list(map(int, input().split()))
pointer = 0
count = 0
for i in range(len(arr)):
	if arr[i] <= t:
		pointer += 1
	else:
		pointer = 0
	if pointer == c:
		count += 1
		pointer -= 1
print(count)


(n, t, c) = map(int, input().split())
data = list(map(int, input().split()))
count = 0
answer = 0
for i in range(len(data)):
	if data[i] > t:
		answer += max(0, count - c + 1)
		count = 0
	else:
		count += 1
answer += max(0, count - c + 1)
print(answer)


(n, t, c) = map(int, input().split())
arr = list(map(int, input().split())) + [t + 1]
var = 0
count = 0
check = 0
for i in range(n):
	if var == 0 and arr[i] <= t:
		start = i
		var = 1
		check = 1
	if var == 1 and arr[i + 1] > t:
		end = i
		var = 0
		if end - start + 1 >= c:
			count += end - start + 1 - c + 1
if check == 0:
	print(0)
else:
	print(count)


(n, t, c) = input().split()
(n, t, c) = (int(n), int(t), int(c))
l = input().split()
for i in range(n):
	l[i] = int(l[i])
i = 0
q = 0
while i < n:
	if l[i] > t:
		i += 1
		continue
	s = 0
	j = i
	while j < n and l[j] <= t:
		s += 1
		j += 1
	if s >= c:
		q += s - c + 1
	i = j
print(q)


(n, t, c) = list(map(int, input().split()))
arr = [int(x) for x in input().split()]
i = 0
j = 0
ans = 0
while j < n:
	if arr[j] > t:
		j += 1
		i = j
	else:
		diff = j - i + 1
		if diff == c:
			ans += 1
			j += 1
			i += 1
		else:
			j += 1
print(ans)


(n, m, k) = [int(x) for x in input().split()]
puzzle = list(map(int, input().split()))
ans = 0
cnt = 0
for x in puzzle:
	if x <= m:
		cnt = cnt + 1
	else:
		cnt = 0
	if cnt >= k:
		ans = ans + 1
print(ans)


(n, t, c) = map(int, input().split())
prisoners = list(map(int, input().split()))
res = 0
last = 0
current = 0
while current < n:
	if prisoners[current] > t:
		current += 1
		last = current
	else:
		moving = current - last + 1
		if moving == c:
			res += 1
			current += 1
			last += 1
		else:
			current += 1
print(res)


import sys
input = lambda : sys.stdin.readline()
int_arr = lambda : list(map(int, input().split()))
str_arr = lambda : list(map(str, input().split()))
get_str = lambda : map(str, input().split())
get_int = lambda : map(int, input().split())
get_flo = lambda : map(float, input().split())
mod = 1000000007

def solve(n, t, c, arr):
	cnt = 0
	i = 0
	ways = 0
	while i < n:
		if arr[i] > t:
			cnt = 0
		else:
			cnt += 1
		if cnt >= c:
			ways += 1
		i += 1
	print(ways)
(n, t, c) = get_int()
arr = int_arr()
solve(n, t, c, arr)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
a.insert(0, 0)
lst = [0 for _ in range(n + 1)]
for p in range(1, n + 1):
	if a[p] > t:
		lst[p] = p
	else:
		lst[p] = lst[p - 1]
ans = 0
for p in range(c, n + 1):
	if lst[p] <= p - c:
		ans += 1
print(ans)


n = input('')
(n, t, c) = n.split(' ')
line = input('')
line = line.split(' ')
line.append('1000000001')
ans = 0
start = 0
current = 0
for x in range(len(line)):
	if int(line[x]) > int(t):
		ans += max(0, x - start + 1 - int(c))
		start = x + 1
print(ans)


def validar(l, a):
	if len(l) < a:
		return 0
	else:
		return 1 + len(l) - a
n = input()
r = [int(x) for x in n.split(' ')]
n1 = input()
r1 = [int(x) for x in n1.split(' ')]
contador = 0
t = []
for k in range(0, len(r1)):
	if r1[k] <= r[1]:
		t.append(r1[k])
	else:
		contador += validar(t, r[2])
		t = []
contador += validar(t, r[2])
print(contador)


(n, t, c) = map(int, input().split())
prisoners = list(map(int, input().split()))
result = count = 0
for i in prisoners:
	if i > t:
		count = 0
	else:
		count += 1
		if count == c:
			count -= 1
			result += 1
if count == c:
	result += 1
print(result)


(n, t, c) = [int(i) for i in input().split()]
row = input().split()
aux = 0
sum = 0
for i in row:
	if t >= int(i):
		aux = aux + 1
	else:
		if c <= aux:
			sum += aux - (c - 1)
		aux = 0
if c <= aux:
	sum += aux - (c - 1)
print(sum)


(n, t, c) = map(int, input().split())
l = input().split()
counter = 0
i = 0
len_of_q = 0
while i < n:
	if int(l[i]) > t:
		len_of_q = 0
		i += 1
		continue
	i += 1
	len_of_q += 1
	if len_of_q >= c:
		counter += 1
print(counter)


from collections import deque
(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
d = deque()
for i in range(c):
	while len(d) and a[i] >= a[d[-1]]:
		d.pop()
	d.append(i)
for i in range(c, n):
	if a[d[0]] <= t:
		ans += 1
	while len(d) and a[i] >= a[d[-1]]:
		d.pop()
	while len(d) and d[0] <= i - c:
		d.popleft()
	d.append(i)
if len(d) and a[d[0]] <= t:
	ans += 1
print(ans)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
b = 0
ans = 0
for i in range(n):
	if a[i] > t:
		ans += max(i - b - c + 1, 0)
		b = i + 1
ans += max(n - b - c + 1, 0)
print(ans)


from collections import deque

def solution(t, c, array):
	queue = deque([0], maxlen=c)
	for i in range(1, c):
		if len(queue) >= 1:
			while array[queue[-1]] <= array[i]:
				queue.pop()
				if len(queue) == 0:
					break
		queue.append(i)
	count = 1 if array[queue[0]] <= t else 0
	for i in range(c, len(array)):
		if i - queue[0] == c:
			queue.popleft()
		if len(queue) >= 1:
			while array[queue[-1]] <= array[i]:
				queue.pop()
				if len(queue) == 0:
					break
		queue.append(i)
		if array[queue[0]] <= t:
			count += 1
	return count

def main():
	(n, t, c) = map(int, input().split(' '))
	array = list(map(int, input().split(' ')))
	print(solution(t, c, array))
testing = False
if testing:
	from random import random
	n = 10
	for _ in range(10000):
		t = int(random() * 20) + 1
		c = int(random() * n) + 1
		a = [int(random() * 20) for _ in range(n)]
		solution(t, c, a)
else:
	main()


(n, t, c) = map(int, input().split())
k = r = 0
for i in input().split():
	k = k + 1 if int(i) <= t else 0
	r += k >= c
print(r)


(n, t, c) = map(int, input().split())
g = 0
data = []
for x in input().split():
	if int(x) > t:
		data.append(g)
	g += 1
if len(data) == 0:
	print(n - c + 1)
else:
	answer = 0
	for i in range(len(data) - 1, 0, -1):
		gg = data[i] - data[i - 1] - 1 - c + 1
		if gg > 0:
			answer += gg
	tz = data[0] - c + 1
	if tz > 0:
		answer += tz
	tz = n - 1 - data[-1] - c + 1
	if tz > 0:
		answer += tz
	print(answer)


import queue
(n, t, c) = map(int, input().split())
lista = list(map(int, input().split()))
maxpre = 0
cont = 0
for i in lista:
	if i > t:
		maxpre = 0
	elif maxpre < c:
		maxpre += 1
	if maxpre == c:
		cont += 1
print(cont)


from sys import stdin
(n, t, c) = map(int, stdin.readline().split())
cnt = 0
ct = 0
for i in map(int, stdin.readline().split()):
	if i <= t:
		ct = ct + 1
	else:
		if ct >= c:
			cnt = cnt + ct - c + 1
		ct = 0
if ct >= c:
	cnt = cnt + ct - c + 1
print(cnt)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
temp = c
total = 0
count = 0
for i in range(0, len(a)):
	if a[i] <= t:
		count += 1
	elif a[i] > t and count >= c:
		total += count - c + 1
		count = 0
	elif a[i] > t and count < c:
		count = 0
if count >= c:
	total += count - c + 1
print(total)


def main():
	(n, t, c) = map(int, input().split())
	crime_level = list(map(int, input().split()))
	lengths = []
	seg_len = 0
	for e in crime_level:
		if e <= t:
			seg_len += 1
		else:
			if seg_len >= c:
				lengths.append(seg_len)
			seg_len = 0
	if seg_len >= c:
		lengths.append(seg_len)
	ans = 0
	for e in lengths:
		ans += e - c + 1
	print(ans)
main()


(n, t, c) = (int(i) for i in input().split())
l = [int(i) for i in input().split()]
d = {1: []}
for i in range(n):
	if l[i] > t:
		d[1].append(i)
n1 = len(d[1])
if n1 == 0:
	print(n - c + 1)
else:
	ans = max(0, d[1][0] - c + 1)
	for i in range(n1 - 1):
		ans += max(0, d[1][i + 1] - d[1][i] - c)
	ans += max(0, n - d[1][n1 - 1] - c)
	print(ans)


(n, t, c) = map(int, input().strip().split())
l = list(map(int, input().strip().split()))
lastgreater = -1
res = 0
for i in range(0, n):
	if l[i] > t:
		lastgreater = i
	if i - lastgreater >= c:
		res += 1
print(res)


__author__ = 'Lipen'

def main():
	(n, t, c) = map(int, input().split())
	v = list(map(int, input().split()))
	k = 0
	answer = 0
	for i in range(n):
		x = v[i]
		if x > t:
			answer += max(0, k - c + 1)
			k = 0
		else:
			k += 1
	answer += max(0, k - c + 1)
	print(answer)
main()


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [Scanner.string() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [Scanner.int() for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def divisor(n):
		res = []
		i = 1
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				res.append(i)
				if i != n // i:
					res.append(n // i)
		return res

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

	@staticmethod
	def is_prime(n):
		if n < 2:
			return False
		if n == 2:
			return True
		if n % 2 == 0:
			return False
		d = int(n ** 0.5) + 1
		for i in range(3, d + 1, 2):
			if n % i == 0:
				return False
		return True

def pop_count(x):
	x = x - (x >> 1 & 6148914691236517205)
	x = (x & 3689348814741910323) + (x >> 2 & 3689348814741910323)
	x = x + (x >> 4) & 1085102592571150095
	x = x + (x >> 8)
	x = x + (x >> 16)
	x = x + (x >> 32)
	return x & 127
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def solve():
	(N, T, C) = Scanner.map_int()
	A = Scanner.map_int()
	ans = 0
	tmp = 0
	for a in A:
		if a > T:
			tmp = 0
		else:
			tmp += 1
			if tmp >= C:
				ans += 1
	print(ans)

def main():
	solve()
main()


from collections import deque
first = input()
(n, t, c) = first.split()
n = int(n)
t = int(t)
c = int(c)
second = input()
nums = [int(x) for x in second.split()]
d = deque()
count = 0
for i in range(n):
	if nums[i] <= t:
		d.append(nums[i])
	else:
		d.clear()
	if len(d) == c:
		count += 1
		d.popleft()
print(count)


import collections as cc
import sys
I = lambda : list(map(int, input().split()))
(n, m, c) = I()
l = I()
ans = 0
co = 0
for i in range(n):
	if l[i] > m:
		co = 0
		continue
	else:
		co += 1
		if co >= c:
			ans += 1
print(ans)


(n, t, c) = map(int, input().split())
pris = list(map(int, input().split()))
result = 0
trig = 0
for i in range(n):
	if pris[i] > t:
		trig = 0
	else:
		trig += 1
	if trig >= c:
		result += 1
print(result)


(n, t, c) = map(int, input().split())
s = [int(i) for i in input().split()]
cnt = 0
d = [-1]
for i in range(n):
	if s[i] > t:
		d.append(i)
d.append(n)
for i in range(len(d) - 1):
	a = d[i + 1] - d[i] - 1
	if a >= c:
		cnt += a - c + 1
print(cnt)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
l = []
k = []
for i in range(len(a)):
	if a[i] > t:
		k.append(l)
		l = []
	else:
		l.append(a[i])
k.append(l)
p = 0
for i in range(len(k)):
	if len(k[i]) - (c - 1) > 0:
		p += len(k[i]) - (c - 1)
print(p)


import sys
import math
import itertools
import functools
import collections
import operator
import fileinput
import copy
ORDA = 97

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=1):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	newnumber = 0
	while number > 0:
		newnumber += number % base
		number //= base
	return newnumber

def cdiv(n, k):
	return n // k + (n % k != 0)
(n, t, c) = mi()
a = li()
b = [0]
for i in range(n):
	if a[i] > t:
		b.append(i + 1)
b.append(n + 1)
ans = 0
for i in range(len(b) - 1):
	ans += max(0, b[i + 1] - b[i] - c)
print(ans)


(n, t, c) = [int(j) for j in input().split()]
p = [int(j) for j in input().split()]
p += [t + 1]
l = 0
s = 0
for i in range(n + 1):
	if p[i] <= t:
		l += 1
	elif l >= c:
		s += l - c + 1
		l = 0
	else:
		l = 0
print(s)


(n, a, b) = map(int, input().split())
l = list(map(int, input().split()))
k = 0
v = 0
for i in range(n):
	if l[i] <= a:
		v = v + 1
	else:
		if v - b >= 0:
			k = k + v - b + 1
		v = 0
if v - b >= 0:
	k = k + v - b + 1
print(k)


from sys import stdin
(n, t, c) = [int(i) for i in stdin.readline().split()]
prisioneros = [int(i) for i in stdin.readline().split()]
count = 0
ans = 0
for i in prisioneros:
	if i <= t:
		count += 1
	else:
		count = 0
	if count >= c:
		ans += 1
print(ans)


inp1 = [int(i) for i in input().split(' ')]
(n, t, c) = (inp1[0], inp1[1], inp1[2])
inp2 = [int(i) for i in input().split(' ')]
i = j = result = 0
while i < n:
	if inp2[i] <= t:
		i += 1
		j += 1
	else:
		if j >= c:
			if n == 1:
				result += j
			else:
				result += j - c + 1
		j = 0
		i += 1
	if j == n or (j == c and i == n):
		result += j - c + 1
print(result)


(n, t, c) = map(int, input().split())
l = list(map(int, input().split()))
curr = 0
ways = 0
for i in range(n):
	if l[i] <= t:
		curr += 1
		if curr == c:
			ways += 1
			curr -= 1
	else:
		curr = 0
print(ways)


(a, b, c) = map(int, input().split())
r = list(map(int, input().split()))
s = 0
t = 0
for i in range(a):
	if r[i] <= b:
		t += 1
		if t >= c:
			s += 1
	else:
		t = 0
print(s)


row = input().split()
row2 = input().split()
n = int(row[0])
t = int(row[1])
c = int(row[2])
aux = 0
cn = 0
for i in range(n):
	if int(row2[i]) <= t:
		cn += 1
	else:
		if cn >= c:
			aux = aux + cn - (c - 1)
		cn = 0
if cn >= c:
	aux = aux + cn - (c - 1)
print(aux)


(number, limit, chosen) = map(int, input().split())
prisioners = list(map(int, input().split()))
sequences = 0
aux = 0
for p in prisioners:
	if p > limit:
		aux = 0
	else:
		aux += 1
	if aux >= chosen:
		sequences += 1
print(sequences)


(n, t, c) = map(int, input().split())
arr = [int(i) for i in input().split()]
x = 0
y = 0
z = 0
for i in range(n):
	if arr[i] > t:
		z = i + 1
		if y - c + 1 > 0:
			x = x + (y - c + 1)
		y = 0
	else:
		y = y + 1
if n - z - c + 1 > 0:
	x = x + (n - z - c + 1)
if x < 0:
	print(0)
else:
	print(x)


(n, t, c) = map(int, input().split())
arr = list(map(int, input().split()))
num_pris = 0
Max = -1
is_pos = True
Bool = [True for i in range(n)]
dp = [True for i in range(n - c + 2)]
for i in range(n):
	if arr[i] > t:
		Bool[i] = False
for i in range(c):
	if Bool[i] is False:
		dp[1] = False
		Max = i
for k in range(c, n):
	if Bool[k] is False:
		Max = k
		dp[k - c + 2] = False
	elif Max > k - c:
		dp[k - c + 2] = False
for i in range(1, len(dp)):
	boo = dp[i]
	if boo:
		num_pris += 1
print(num_pris)


(n, t, c) = map(int, input().split())
l_p = list(map(int, input().split()))
t_c = 0
i = 0
c_l = 0
while i < n:
	if l_p[i] <= t:
		c_l += 1
	else:
		c_l = 0
	if c_l >= c:
		t_c += 1
	i += 1
print(t_c)


(n, t, c) = [int(i) for i in input().split()]
result = 0
danger = -1
for (i, v) in enumerate((int(i) for i in input().split())):
	if v > t:
		danger = i
	elif i - danger >= c:
		result += 1
print(result)


(n, t, c) = list(map(int, input().split()))
arr = list(map(int, input().split()))
count = 0
start = 0
for i in range(1, n):
	if arr[i] > t:
		count += max(i - start - c + 1, 0)
		start = i + 1
if arr[n - 1] <= t:
	count += max(n - start - c + 1, 0)
print(count)


(a, b, c) = map(int, input().split())
l = list(map(int, input().split()))
ans = []
for i in range(len(l)):
	if l[i] <= b:
		ans.append(True)
	else:
		ans.append(False)
d = []
base = 0
for i in range(len(ans)):
	if ans[i] == True:
		base = base + 1
	elif ans[i] == False:
		d.append(base)
		base = 0
	if i == len(ans) - 1:
		d.append(base)
e = sum([i - (c - 1) for i in d if i >= c])
print(e)


(n, t, c) = (int(X) for X in input().split())
L = [int(X) for X in input().split()]
a = -1
A = []
for i in range(n):
	if L[i] <= t:
		if a == -1:
			if c == 1 and i == n - 1:
				A.append(1)
			else:
				a = i
		elif i == n - 1 and n - a - c + 1 > 0:
			A.append(n - a - c + 1)
	elif a != -1:
		if i - a - c + 1 > 0:
			A.append(i - a - c + 1)
		a = -1
print(sum(A))


from collections import deque
(n, t, c) = map(int, input().split())
prisoners = list(map(int, input().split()))
q = deque()
i = 0
count = 0
while i < n:
	p = prisoners[i]
	if len(q) < c:
		if p > t:
			q = deque()
		else:
			q.append(prisoners[i])
	if len(q) == c:
		count += 1
		q.popleft()
	i += 1
print(count)


(n, t, c) = map(int, input().split())
sv = list(map(int, input().split()))
cnt = 0
ans = 0
for i in range(n):
	if sv[i] <= t:
		cnt += 1
		if cnt >= c:
			ans += 1
	else:
		cnt = 0
print(ans)


(n, t, c) = list(map(int, input().split()))
l = list(map(int, input().split()))
i = 0
y = 0
j = 0
p = []
while i < len(l):
	if l[i] > t:
		p.append(i)
	i += 1
k = 0
for j in p:
	r = j - k
	if r >= c:
		y += r - c + 1
	else:
		y += 0
	k = j + 1
if len(p) == 0:
	if n >= c:
		y += n - c + 1
	else:
		y += 0
else:
	r = n - j - 1
	if r >= c:
		y += r - c + 1
	else:
		y += 0
print(y)


(N, T, C) = map(int, input().split())
pics = [-1]
for (index, s) in enumerate(map(int, input().split())):
	if s > T:
		pics.append(index)
pics.append(N)
ans = 0
for (picIndex, pic) in enumerate(pics):
	diff = pic - pics[picIndex - 1] - 1
	ans += max(diff - C + 1, 0)
print(ans)


(n, t, k) = map(int, input().split())
l = list(map(int, input().split()))
r = [-1]
for i in range(n):
	if l[i] > t:
		r.append(i)
ans = 0
r.append(n)
for i in range(len(r)):
	diff = r[i] - r[i - 1] - 1
	ans += max(diff - k + 1, 0)
print(ans)


(n, t, c) = map(int, input().split())
l = list(map(int, input().split()))
(ans, tp) = (0, 0)
for i in range(n):
	if l[i] > t:
		l1 = i - tp
		ans += max(0, l1 - c + 1)
		tp = i + 1
i += 1
l1 = i - tp
ans += max(0, l1 - c + 1)
print(ans)


(n, t, c) = [int(c) for c in input().split()]
cruelty = [int(c) for c in input().split()]
res = 0
current_length = 0
for i in cruelty:
	if i <= t:
		current_length += 1
	else:
		if current_length >= c:
			res += current_length - c + 1
		current_length = 0
if current_length >= c:
	res += current_length - c + 1
print(res)


from os import path
import sys
from heapq import heappush, heappop
from functools import cmp_to_key as ctk
from collections import deque, defaultdict as dd
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from itertools import permutations
from datetime import datetime
from math import ceil, sqrt, log, gcd

def ii():
	return int(input())

def si():
	return input().rstrip()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def bo(i):
	return ord(i) - ord('0')
file = 1

def solve():
	(n, t, s) = mi()
	a = li()
	c = 0
	s -= 1
	ans = 0
	for x in a:
		if x > t:
			if c >= s:
				ans += c - s
			c = 0
		else:
			c += 1
	if c >= s:
		ans += c - s
	print(ans)
if file:
	if path.exists('input.txt'):
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	else:
		input = sys.stdin.readline
solve()


(n, t, c) = map(int, input().split())
arr = list(map(int, input().split()))
(i, j, res) = (0, 0, 0)
while i < n:
	while i < n and arr[i] <= t:
		i += 1
	r = i - j
	if r >= c:
		res += r - c + 1
	i += 1
	j = i
print(res)


r = lambda : map(int, input().split())
(n, t, c) = r()
last = -1
p = list(r())
total = 0
for (i, x) in enumerate(p):
	if x > t:
		last = i
		continue
	if i >= last + c:
		total += 1
print(total)


from sys import stdin
input = lambda : stdin.readline().strip()
from math import ceil, sqrt, factorial
INT_MIN = float('-infinity')
INT_MAX = float('infinity')
(n, t, c) = map(int, input().split())
l = list(map(int, input().split()))
z = [-1]
for i in range(n):
	if l[i] > t:
		z.append(i)
z.append(n)
ans = 0
for i in range(1, len(z)):
	if z[i] - z[i - 1] - 1 >= c:
		ans += z[i] - z[i - 1] - 1 - c + 1
print(ans)


l1 = input().split(' ')
n = int(l1[0])
t = int(l1[1])
c = int(l1[2])
ways = 0
arr = []
l2 = input().split(' ')
for a in l2:
	arr.append(int(a))
cut = [0]
for j in range(len(arr)):
	sever = arr[j]
	if sever > t:
		cut.append(j)
cut.append(len(arr) - 1)
import math
if len(cut) == 2:
	if len(arr) >= c:
		ways += len(arr) - c + 1
	else:
		ways = 0
else:
	for d in range(len(cut) - 1):
		ele1 = cut[d]
		ele2 = cut[d + 1]
		if d == 0 or d == len(cut) - 2:
			if ele2 - ele1 >= c:
				ways += ele2 - ele1 - c + 1
		else:
			diff = ele2 - ele1 - 1
			if diff >= c:
				ways += diff - c + 1
print(ways)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
p = []
k = 0
i = 0
while i < n:
	if a[i] > t:
		b = a[k:i]
		if len(b) > 0:
			p.append(b)
		k = i + 1
	i += 1
b = a[k:n]
if len(b) > 0:
	p.append(b)
f = 0
for i in p:
	if len(i) >= c:
		f += len(i) - c + 1
print(f)


(n, t, c) = map(int, input().split())
m = 0
j = 0
for i in map(int, input().split()):
	if i <= t:
		j += 1
	else:
		if j >= c:
			m += j - c + 1
		j = 0
if j >= c:
	m += j - c + 1
print(m)


(n, t, c) = [int(i) for i in input().split()]
array = [int(i) if int(i) <= t else '@' for i in input().split()]
count = 0
soma = 0
array.append('@')
for i in array:
	if i == '@':
		if count >= c:
			soma += count - c + 1
		count = 0
	else:
		count += 1
print(soma)


(n, t, c) = [int(i) for i in input().split()]
ls = [int(i) for i in input().split()]
ans = 0
i = 0
count = 0
while i < n:
	if ls[i] <= t:
		count += 1
	else:
		count = 0
	if count == c:
		ans += 1
		count -= 1
	i += 1
print(ans)


def solve(arr, t, c):
	if c == 0:
		return 0
	if t == 0:
		return 0
	count = 0
	ans = 0
	for i in range(len(arr)):
		if arr[i] <= t:
			count += 1
		else:
			if count >= c:
				ans += count - c + 1
			count = 0
	if count >= c:
		ans += count - c + 1
	return ans
(n, t, c) = map(int, input().split())
arr = list(map(int, input().split()))
print(solve(arr, t, c))


(totalPrisioneiros, limiteCrime, quantidadePrisioneiros) = [int(x) for x in input().split()]
listaPrisioneiros = [int(x) for x in input().split()]
listaContinua = []
contador = 0
for i in listaPrisioneiros:
	if i > limiteCrime:
		if contador > 0:
			listaContinua.append(contador)
		contador = 0
	else:
		contador += 1
else:
	if contador > 0:
		listaContinua.append(contador)
contador = 0
for i in listaContinua:
	if i >= quantidadePrisioneiros:
		contador += i - quantidadePrisioneiros + 1
print(contador)


(n, t, c) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
k = 0
p = 0
i = 0
for i in a:
	if i <= t:
		p += 1
	else:
		if p >= c:
			k += p - c + 1
		p = 0
if p >= c:
	k += p - c + 1
print(k)


a = list(map(int, input().split()[1:]))
b = list(map(int, input().split()))
m = 0
c = 0
for i in b:
	if i > a[0]:
		if not c < a[1]:
			m += c - a[1] + 1
		c = 0
	else:
		c += 1
print(m + c - a[1] + 1 if c >= a[1] else m)


from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353

def inp():
	return stdin.readline().strip()

def iinp():
	return int(inp())

def out(var, end='\n'):
	stdout.write(str(var) + '\n')

def outa(*var, end='\n'):
	stdout.write(' '.join(map(str, var)) + end)

def lmp():
	return list(mp())

def mp():
	return map(int, inp().split())

def smp():
	return map(str, inp().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(m, val) for j in range(n)]

def remadd(x, y):
	return 1 if x % y else 0

def ceil(a, b):
	return (a + b - 1) // b
S1 = 'abcdefghijklmnopqrstuvwxyz'
S2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

def isprime(x):
	if x <= 1:
		return False
	if x in (2, 3):
		return True
	if x % 2 == 0:
		return False
	for i in range(3, int(sqrt(x)) + 1, 2):
		if x % i == 0:
			return False
	return True
(n, t, c) = mp()
arr = lmp()
inds = [-1]
for i in range(n):
	if arr[i] > t:
		inds.append(i)
inds.append(n)
ans = 0
for i in range(1, len(inds)):
	ans += max(0, inds[i] - inds[i - 1] - c)
print(ans)


(n, t, c) = map(int, input().strip().split())
a = list(map(int, input().strip().split()))
count = 0
op = 0
for i in a:
	if i > t:
		if count >= c:
			op = op + count - c + 1
		count = 0
	else:
		count = count + 1
if count >= c:
	op = op + count - c + 1
print(op)


(n, t, c) = map(int, input().split())
(res, cnt) = (0, 0)
for el in map(int, input().split()):
	if el > t:
		res += max(0, cnt - c + 1)
		cnt = 0
	else:
		cnt += 1
print(res + max(0, cnt - c + 1))


(X, Severity, Count) = (list(map(int, input().split())), list(map(int, input().split())), 0)
i = 0
Counter = 0
while i < X[0]:
	if Severity[i] > X[1]:
		Count += max(0, Counter - X[2] + 1)
		Counter = 0
	else:
		Counter += 1
	i += 1
Count += max(0, Counter - X[2] + 1)
print(Count)


a = []
a.append(-1)
(n, t, c) = map(int, input().split())
b = [int(i) for i in input().split()]
for i in range(n):
	if b[i] > t:
		a.append(i)
a.append(n)
ans = 0
for i in range(len(a) - 1):
	if a[i + 1] - a[i] - 1 >= c:
		ans += a[i + 1] - a[i] - c
print(ans)


def lmap():
	return list(map(int, input().split()))
(n, t, c) = map(int, input().split())
w = lmap()
w.append(t + 1)
ans = []
cpr = 0
prs = 0
flg = 0
for i in range(n + 1):
	if w[i] <= t:
		cpr += 1
	elif w[i] > t:
		flg = 1
		if cpr < c:
			cpr = 0
		else:
			prs += cpr - (c - 1)
			cpr = 0
if flg == 0:
	print(cpr - (c - 1))
else:
	print(prs)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
s = 0
for i in a:
	if i <= t:
		s += 1
	elif i > t and s >= c:
		ans += s - c + 1
		s = 0
	elif i > t and s < c:
		s = 0
if s >= c:
	ans += s - c + 1
print(ans)


s = 0
ans = 0
(n, t, c) = map(int, input().split())
for i in map(int, input().split()):
	if i <= t:
		s += 1
	else:
		s = 0
	if s >= c:
		ans += 1
print(ans)


(n, t, c) = [int(i) for i in input().split()]
s = [int(i) for i in input().split()]
k = 0
num = 0
for i in s:
	if i <= t:
		k += 1
		if k >= c:
			num += 1
	else:
		k = 0
print(num)


fast = lambda : stdin.readline().strip()
zzz = lambda : [int(i) for i in fast().split()]
(z, zz) = (input, lambda : list(map(int, z().split())))
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from re import *
from sys import *
from math import *
from heapq import *
from queue import *
from bisect import *
from string import *
from itertools import *
from collections import *
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from collections import Counter as cc
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2 or x == 0:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = 1
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)

def output(answer):
	stdout.write(str(answer))
(n, t, c) = zzz()
arr = zzz()
s = 0
ans = 0
for i in range(n):
	if arr[i] <= t:
		s += 1
		if s >= c:
			ans += 1
		else:
			pass
	else:
		s = 0
print(ans)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
count = 0
vis = []
vis.append(-1)
for i in range(n):
	if a[i] > t:
		vis.append(i)
vis.append(n)
count = 0
for i in range(1, len(vis)):
	diff = vis[i] - vis[i - 1] - 1
	count += max(diff - c + 1, 0)
print(count)


(n, t, c) = map(int, input().split())
vals = list(map(int, input().split()))
counter = 0
i = 0
mini = c - 1
while i < n:
	if vals[i] > t:
		mini = i + c
	if i >= mini:
		counter += 1
	i += 1
print(counter)


(n, limit, janela) = input().split()
n = int(n)
limit = int(limit)
janela = int(janela)
presos = [*map(int, input().split())]
count = 0
i = 0
acc = 0
while i < n:
	if presos[i] <= limit:
		acc += 1
		i += 1
		if acc >= janela:
			count += 1
	else:
		acc = 0
		i += 1
print(count)


(n, t, c) = map(int, input().split())
arr = list(map(int, input().split()))
ans = []
temp = []
for i in arr:
	if i <= t:
		temp.append(i)
	else:
		ans.append(temp[:])
		temp = []
if temp:
	ans.append(temp)
out = 0
for i in ans:
	if len(i) >= c:
		out += len(i) - c + 1
print(out)


(presos, crime_maximo, tamanho_maximo) = map(int, input().split())
crimes = map(int, input().split())
(possiveis, fila_atual) = (0, 0)
for crime in crimes:
	if crime <= crime_maximo:
		fila_atual += 1
		if fila_atual >= tamanho_maximo:
			possiveis += 1
	else:
		fila_atual = 0
print(possiveis)


(n, t, c) = map(int, input().split())
pri = list(map(int, input().split())) + [t + 1]
ans = 0
aux = 0
for p in pri:
	if p <= t:
		aux += 1
	else:
		if aux >= c:
			ans += aux - (c - 1)
		aux = 0
print(ans)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	if a[i] > t:
		a[i] == 1
	else:
		a[i] = 0
now = sum(a[0:c])
cou = 0
if now == 0:
	cou += 1
for i in range(1, n - c + 1):
	now -= a[i - 1]
	now += a[i + c - 1]
	if now == 0:
		cou += 1
print(cou)


(n, t, c) = [int(x) for x in input().split()]
array = [int(x) for x in input().split()]
if n < c:
	print(0)
else:
	ini = 0
	fim = 0
	count = 0
	while fim < n:
		if array[fim] > t:
			ini = fim + 1
		if fim - ini + 1 >= c:
			count += 1
		fim += 1
	print(count)


(n, t, c) = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
cnt = 0
ans = 0
for x in l:
	if x <= t:
		cnt += 1
	else:
		cnt = 0
	if cnt >= c:
		ans += 1
print(ans)


(n, t, c) = map(int, input().split())
v = list(map(int, input().split()))
f = []
cont1 = 0
conTot = 0
for i in range(n):
	if v[i] <= t:
		cont1 += 1
	else:
		cont1 = 0
	if cont1 >= c:
		conTot += 1
print(conTot)


(n, t, c) = map(int, input().split())
nivelCrime = list(map(int, input().split()))
cnt = 0
ansFinal = 0
for i in nivelCrime:
	if i <= t:
		cnt += 1
		if cnt >= c:
			ansFinal += 1
	else:
		cnt = 0
print(ansFinal)


import math
from decimal import *
(n, t, c) = map(int, input().split())
arr = list(map(int, input().split()))
cnt = 0
ans = 0
for i in range(n):
	if arr[i] <= t:
		cnt += 1
	else:
		if cnt >= c:
			ans += cnt - c + 1
		cnt = 0
if cnt >= c:
	ans += cnt - c + 1
print(ans)


def solution(t, c, P):
	cons = ret = 0
	for p in P:
		if p <= t:
			cons += 1
		else:
			cons = 0
		if c <= cons:
			ret += 1
	return ret
(n, t, c) = map(int, input().split())
P = map(int, input().split())
print(solution(t, c, P))


R = lambda : map(int, input().split())
(n, t, c) = R()
a = list(R())
gt = 0
for i in range(c):
	if a[i] > t:
		gt += 1
ans = 0
a.append(0)
for i in range(n - c + 1):
	if gt == 0:
		ans += 1
	if a[i] > t:
		gt -= 1
	if a[i + c] > t:
		gt += 1
print(ans)


(n, t, c) = [int(x) for x in input().split()]
ex_id = [-1] + [i for (i, v) in enumerate(input().split()) if int(v) > t] + [n]
ans = 0
for i in range(1, len(ex_id)):
	diff = ex_id[i] - ex_id[i - 1] - 1
	ans += max(diff - c + 1, 0)
print(ans)


def main():
	(n, t, c) = map(int, input().split())
	a = b = 0
	for x in map(int, input().split()):
		if x <= t:
			b += 1
			a += b >= c
		else:
			b = 0
	print(a)
main()


cnt = lambda s, x: s.count(x)
ii = lambda : int(input())
si = lambda : input()
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
(n, t, c) = f()
l = il()
ct = 0
k = 0
for i in l:
	if i <= t:
		k += 1
		if k == c:
			ct += 1
			k -= 1
	else:
		k = 0
print(ct)


import sys, threading, os.path
import string
import collections, heapq, math, bisect
sys.setrecursionlimit(10 ** 6)
threading.stack_size(2 ** 27)

def main():
	if os.path.exists('in.txt'):
		input = open('in.txt', 'r')
	else:
		input = sys.stdin
	(n, t, c) = list(map(int, input.readline().split()))
	lis = list(map(int, input.readline().split()))
	(segment, count) = (0, 0)
	for i in range(len(lis)):
		if lis[i] > t:
			segment = 0
		elif lis[i] <= t and segment < c:
			segment += 1
		if segment == c and lis[i] <= t:
			count += 1
	output = count
	if os.path.exists('out.txt'):
		open('out.txt', 'w').writelines(str(output))
	else:
		sys.stdout.write(str(output))
main()


import sys
f = sys.stdin
(n, t, c) = map(int, f.readline().split())
s = f.readline().split()
total = 0
r = 0
for j in s:
	d = int(j)
	if d <= t:
		r += 1
	else:
		if r >= c:
			total += r - c + 1
		r = 0
if r >= c:
	total += r - c + 1
print(str(total))


from collections import Counter
(n, t, c) = map(int, input().split())
l = list(map(int, input().split()))
k = 0
count = 0
for i in range(len(l)):
	if l[i] <= t:
		k = k + 1
	else:
		k = 0
	if k == c:
		count = count + 1
		k = c - 1
print(count)


(n, t, c) = [int(i) for i in input().split()]
ps = [int(i) for i in input().split()]
count = 0
res = 0
for p in ps:
	if p > t:
		if count >= c:
			res += count - c + 1
		count = 0
	else:
		count += 1
if count >= c:
	res += count - c + 1
print(res)


(n, t, k) = map(int, input().split())
s = [int(i) for i in input().split()]
c = 0
i = 0
d = 0
while d < n:
	g = s[d]
	if g <= t:
		c += 1
	if g > t or d == n - 1:
		if c >= k:
			i += c - (k - 1)
			c = 0
			b = []
		else:
			c = 0
	d = d + 1
print(i)


(a, b, c) = map(int, input().split())
l = [int(s) for s in input().split()]
l1 = []
c1 = 0
for i in range(a):
	if l[i] <= b:
		l1.append(l[i])
	else:
		if len(l1) >= c:
			c1 += len(l1) - c + 1
		l1 = []
if len(l1) >= c:
	c1 += len(l1) + 1 - c
print(c1)


from sys import stdin, stdout
(n, t, c) = map(int, stdin.readline().split())
arr = [int(i) for i in stdin.readline().split()]
i = 0
l = 0
ans = 0
while i < len(arr):
	if arr[i] <= t:
		l += 1
	else:
		ans += max(l - c + 1, 0)
		l = 0
	i += 1
ans += max(l - c + 1, 0)
stdout.write(str(ans))


(n, t, c) = [int(x) for x in input().split()]
p = [int(x) for x in input().split()]
ch = []
count = 0
res = 0
for i in range(len(p)):
	if p[i] <= t:
		count += 1
		if count == c:
			res += 1
			count = c - 1
	else:
		count = 0
print(res)


(n, t, c) = map(int, input().split())
z = list(map(int, input().split()))
a = b = r = 0
while b < len(z):
	if z[b] > t:
		p = b - a - c + 1
		r += p if p > 0 else 0
		a = b + 1
	b += 1
p = b - a - c + 1
r += p if p > 0 else 0
print(r)


(n, t, c) = map(int, input().split())
l = list(map(int, input().split())) + [t + 1]
foo = 0
q = 0
for i in l:
	if i <= t:
		q += 1
	else:
		if q + 1 > c:
			foo += q - (c - 1)
		q = 0
print(foo)


(n, t, c) = map(int, input().split())
criminals = list(map(int, input().split()))
ways = 0
lo = 0
hi = 0
while hi < n:
	if criminals[hi] > t:
		hi += 1
		lo = hi
		continue
	if hi - lo + 1 < c:
		hi += 1
	else:
		lo += 1
		hi += 1
		ways += 1
print(ways)


(n, t, c) = map(int, input().split())
l = list(map(int, input().split()))
ce = 0
cc = []
for x in l:
	if x > t:
		cc.append(ce)
		ce = 0
	else:
		ce += 1
cc.append(ce)
to = 0
for x in cc:
	if x >= c:
		to += x - c + 1
print(to)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
M = 0
res = n - c + 1
end_index = n - c
last = -float('inf')
for i in range(n):
	if a[i] > t:
		start = max(i - (c - 1), 0)
		end = min((end_index, i))
		start = max(last + 1, start)
		last = i
		yy = end - start + 1
		if yy > 0:
			res -= yy
print(res)


(n, t, c) = input().split()
n = int(n)
t = int(t)
c = int(c)
p = input().split(' ')
for i in range(n):
	p[i] = int(p[i])
parts = []
ans = 0
last = -1
for i in range(n):
	if p[i] > t:
		parts.append(i - last - 1)
		last = i
parts.append(len(p) - last - 1)
for i in parts:
	possibilities = i - c + 1
	if possibilities > 0:
		ans = ans + possibilities
print(ans)


n_t_c = input()
input_list = n_t_c.split()
total_prisoners = int(input_list[0])
max_crime_level = int(input_list[1])
transfer_prisoners = int(input_list[2])
crime_levels = input()
crime_levels = crime_levels.split()
for i in range(len(crime_levels)):
	crime_levels[i] = int(crime_levels[i])
number_of_ways = 0
i = 0
initial_index = 0
while i < total_prisoners:
	if crime_levels[i] > max_crime_level:
		number_of_ways += max(i - initial_index - transfer_prisoners + 1, 0)
		initial_index = i + 1
	if i == total_prisoners - 1 and crime_levels[i] <= max_crime_level:
		number_of_ways += max(i - initial_index - transfer_prisoners + 2, 0)
	i += 1
print(number_of_ways)


(n, t, c) = map(int, input().split())
ans = 0
l = list(map(int, input().split()))
i = 0
while i < n:
	j = i
	cnt = 0
	while j < n and l[j] <= t:
		j += 1
		cnt += 1
		i = j
	if cnt >= c:
		ans += cnt - c + 1
	i += 1
print(ans)


(n, t, c) = list(map(int, input().split(' ')))
severity = list(map(int, input().split(' ')))
total = ini = 0
subsets = []
severity.append(10000000000)
for i in range(len(severity)):
	if severity[i] > t:
		subsets.append(severity[ini:i])
		ini = i + 1
if len(subsets) == 0:
	subsets.append(severity)
for i in subsets:
	if len(i) - c + 1 > 0:
		total += len(i) - c + 1
print(total)


need_log = False

def log(*s):
	if need_log:
		print(*s)
(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
if c == 0:
	print(0)
	return
g = []
k = 0
for i in a:
	if i <= t:
		k += 1
	elif k > 0:
		g += [k]
		k = 0
if k > 0:
	g += [k]
log(g)
result = 0
for i in g:
	result += max(i - c + 1, 0)
print(result)


(n, t, c) = map(int, input().split())
ways = group = 0
for crime_level in map(int, input().split()):
	if crime_level > t:
		(ways, group) = (ways + max(0, group - c + 1), 0)
	else:
		group += 1
print(ways + max(0, group - c + 1))


class InputHandlerObject(object):
	inputs = []

	def getInput(self, n=0):
		res = ''
		inputs = self.inputs
		if not inputs:
			inputs.extend(input().split(' '))
		if n == 0:
			res = inputs[:]
			inputs[:] = []
		while n > len(inputs):
			inputs.extend(input().split(' '))
		if n > 0:
			res = inputs[:n]
			inputs[:n] = []
		return res
InputHandler = InputHandlerObject()
g = InputHandler.getInput
(n, t, c) = [int(x) for x in g()]
a = [False if int(x) > t else True for x in g()]
ct = 0
res = 0
for i in a:
	if i:
		ct += 1
		if ct >= c:
			res += 1
	else:
		ct = 0
print(res)


def main():
	(n, t, c) = [int(c) for c in input().split()]
	s = [int(c) for c in input().split()] + [t + 1]
	cnt = res = 0
	for e in s:
		if e <= t:
			cnt += 1
		else:
			if cnt >= c:
				res += cnt - c + 1
			cnt = 0
	print(res)
main()


(n, t, c) = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
ways = 0
temp = []
for i in arr:
	if i <= t:
		temp.append(i)
	else:
		if len(temp) >= c:
			ways += len(temp) - c + 1
		temp.clear()
if len(temp) >= c:
	ways += len(temp) - c + 1
	temp.clear()
print(ways)


(n, t, c) = map(int, input().split())
C = list(map(int, input().split()))
k = 0
r = 0
for i in range(n):
	if C[i] <= t:
		k += 1
	else:
		r += max(0, k - c + 1)
		k = 0
print(r + max(0, k - c + 1))


(n, t, c) = map(int, input().split())
A = map(int, input().split())
B = [0]
for i in A:
	if i > t and B[-1] != 0:
		B.append(0)
	elif i <= t:
		B[-1] += 1
res = 0
for i in B:
	res += 0 if i - c + 1 < 0 else i - c + 1
print(res)


(n, t, c) = [int(x) for x in input().split()]
prisoners = [int(x) for x in input().split()]
total = 0
current = 0
for i in prisoners:
	if i > t:
		if current >= c:
			total += current - c + 1
		current = 0
	else:
		current += 1
if current >= c:
	total += current - c + 1
print(total)


(n, t, c) = input().split(' ')
arr = input().split(' ')
(n, t, c) = (int(n), int(t), int(c))
arr = [int(x) for x in arr]
(start, end, count) = (0, 0, 0)
while start < n:
	if arr[start] <= t:
		while end < n and arr[end] <= t:
			end += 1
		count += max(end - start - c + 1, 0)
		(start, end) = (end, end)
	else:
		(start, end) = (start + 1, start + 1)
print(count)


(n, t, c) = map(int, input().split())
b = 0
count = 0
for x in map(int, input().split()):
	if x <= t:
		b += 1
	else:
		b = 0
	if b >= c:
		count += 1
print(count)


(n, k, c) = map(int, input().split())
ans = v = 0
for i in input().split():
	if int(i) > k:
		v = 0
	else:
		v += 1
	if v >= c:
		ans += 1
print(ans)


(n, t, c) = list(map(int, input().split()))
presos = list(map(int, input().split()))
temp = 0
temp2 = 0
for e in presos:
	if e <= t:
		temp += 1
	else:
		if temp >= c:
			temp2 += temp - c + 1
		temp = 0
else:
	if temp >= c:
		temp2 += temp - c + 1
print(temp2)


(n, t, c) = map(int, input().split())
x = list(map(int, input().split()))
ans = 0
cnt = 0
for i in range(n):
	if x[i] <= t:
		cnt += 1
	if x[i] > t or i == n - 1:
		if cnt >= c:
			ans += cnt - c + 1
		cnt = 0
print(ans)


(n, t, c) = map(int, input().split())
v = [-1]
for (i, j) in enumerate(input().split()):
	temp = int(j)
	if temp > t:
		v.append(i)
v.append(n)
ans = 0
for i in range(1, len(v)):
	diff = v[i] - v[i - 1] - 1
	ans += max(diff - c + 1, 0)
print(ans)


import bisect
import collections
import copy
import functools
import heapq
import itertools
import math
import random
import re
import sys
import time
import string
from typing import List
sys.setrecursionlimit(99999)
(n, t, c) = map(int, sys.stdin.readline().split())
l = 0
ans = 0
for nt in map(int, sys.stdin.readline().split()):
	if nt > t:
		l = 0
	else:
		l += 1
	ans += l >= c
print(ans)


(n, t, c) = list(map(int, input().split()))
a = list(map(int, input().split()))
(i, p, l) = (0, 0, 0)
while i < c:
	if a[i] > t:
		p += 1
	i += 1
if p == 0:
	l += 1
while i < n:
	if a[i] > t:
		p += 1
	if a[i - c] > t:
		p -= 1
	if p == 0:
		l += 1
	i += 1
print(l)


string = input().split()
n = int(string[0])
t = int(string[1])
c = int(string[2])
a = list(map(int, input().split()))
kol = 0
for i in range(c):
	if a[i] > t:
		kol += 1
if kol == 0:
	ans = 1
else:
	ans = 0
for i in range(c, n):
	if a[i - c] > t:
		kol -= 1
	if a[i] > t:
		kol += 1
	if kol == 0:
		ans += 1
print(ans)


MP = lambda : map(int, input().split())
(n, t, c) = MP()
severity = list(MP()) + [float('infinity')]
(l, a) = (0, 0)
for s in severity:
	if s > t:
		a += max(l - c + 1, 0)
		l = 0
	else:
		l += 1
print(a)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
a.append(t + 1)
ans = 0
curr = 0
for i in a:
	if i <= t:
		curr += 1
	else:
		if curr >= c:
			ans += curr - c + 1
		curr = 0
print(ans)


(n, t, c) = map(int, input().split())
line = list(map(int, input().split()))
line.append(t + 1)
num = res = 0
for i in range(n + 1):
	if line[i] > t:
		if num >= c:
			res += 1 + num - c
		num = 0
	else:
		num += 1
print(res)


R = lambda : list(map(int, input().split()))
(n, t, c) = R()
a = R()
isStart = True
i = 0
ans = 0
while i < n:
	if isStart and i <= n - c:
		j = i
		while j <= i + c - 1:
			if a[j] > t:
				break
			j += 1
		if j > i + c - 1:
			isStart = False
			ans += 1
			i += c - 1
		else:
			isStart = True
			i = j
	elif not isStart:
		if a[i] <= t:
			ans += 1
			isStart = False
		else:
			isStart = True
	i += 1
print(ans)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
for i in range(n):
	if a[i] > t:
		a[i] = ' '
	else:
		a[i] = 'G'
s = ''.join(a).split()
for i in s:
	ans += max(0, len(i) - c + 1)
print(ans)


(n, t, c) = map(int, input().split())
list1 = list(map(int, input().split()))
lst = []
sum1 = 0
for i in range(n):
	if list1[i] <= t:
		lst.append(list1[i])
	elif len(lst) >= c:
		sum1 += len(lst) - c + 1
		lst = []
	else:
		lst = []
if len(lst) >= c:
	sum1 += len(lst) - c + 1
print(sum1)


(_, t, c) = tuple(map(int, str.split(input())))
index = -1
count = 0
for (i, ct) in enumerate(map(int, str.split(input()))):
	if ct > t:
		index = i
	elif i - index >= c:
		count += 1
print(count)


(n, t, c) = map(int, input().split())
p = list(map(int, input().split()))
g = []
a = -1
for i in range(n):
	if p[i] > t:
		g.append(i - a - 1)
		a = i
g.append(n - a - 1)
w = 0
for i in g:
	if i >= c:
		w += i - c + 1
print(w)


(n, t, c) = map(int, input().split())
p = list(map(int, input().split()))
pCount = count = 0
for i in range(len(p)):
	if p[i] > t:
		pCount = 0
	else:
		pCount += 1
	if pCount == c:
		count += 1
		pCount -= 1
print(count)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
j = 0
x = 0
for i in range(n):
	if a[i] <= t:
		j += 1
	elif a[i] > t:
		j = 0
	if j == c:
		x += 1
		j -= 1
print(x)


a = list(map(int, input().split()))
b = list(map(int, input().split()))
start = -1
answer = 0
for x in range(a[0]):
	if b[x] > a[1]:
		start = x
	if x - start >= a[2]:
		answer += 1
print(answer)


(n, t, c) = map(int, input().split())
a = list(map(int, input().split()))
stack = list()
stack.append(-1)
for i in range(n):
	if a[i] > t:
		stack.append(i)
stack.append(n)
ans = 0
for i in range(len(stack) - 1):
	ll = stack[i + 1] - stack[i] - 1
	ans += max(0, ll - c + 1)
print(ans)


(all_prisioners, crime_limit, transfer_prisioners) = map(int, input().split())
crime_level = list(map(int, input().split()))
total_ways = 0
size = 0
for i in range(all_prisioners):
	if crime_level[i] <= crime_limit:
		size += 1
	else:
		if size >= transfer_prisioners:
			total_ways += size - transfer_prisioners + 1
		size = 0
	i += 1
if size >= transfer_prisioners:
	total_ways += size - transfer_prisioners + 1
print(total_ways)


(n, t, c) = map(int, input().split(' '))
l = list(map(int, input().split(' ')))
a = [-1]
for i in range(0, n):
	if l[i] > t:
		a.append(i)
a.append(n)
k = len(a)
total = 0
for i in range(1, k):
	diff = a[i] - a[i - 1] - 1
	if diff >= c:
		total = total + (diff - c) + 1
print(total)


from math import factorial
(n, t, c) = list(map(int, input().split()))
a = list(map(int, input().split()))
t1 = 0
r = 0
for i in range(n):
	if a[i] <= t:
		t1 += 1
		if t1 >= c:
			r += 1
	else:
		t1 = 0
print(r)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [tuple(map(int, l.split())) for l in sys.stdin]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	(n, t, c) = LI()
	a = LI()
	k = 0
	for i in range(c):
		if a[i] > t:
			k += 1
	r = 0
	if k == 0:
		r += 1
	for i in range(c, n):
		if a[i] > t:
			k += 1
		if a[i - c] > t:
			k -= 1
		if k == 0:
			r += 1
	return r
print(main())