Snuke has a permutation (P_0,P_1,\cdots,P_{N-1}) of (0,1,\cdots,N-1).

Now, he will perform the following operation exactly once:

* Choose K consecutive elements in P and sort them in ascending order.



Find the number of permutations that can be produced as P after the operation.

Constraints

* 2 \leq N \leq 200000
* 2 \leq K \leq N
* 0 \leq P_i \leq N-1
* P_0,P_1,\cdots,P_{N-1} are all different.
* All values in input are integers.

Input

Input is given from Standard Input in the following format:


N K
P_0 P_1 \cdots P_{N-1}


Output

Print the number of permutations that can be produced as P after the operation.

Examples

Input

5 3
0 2 1 4 3


Output

2


Input

4 4
0 1 2 3


Output

1


Input

10 4
2 0 1 3 7 5 4 6 8 9


Output

6
from collections import deque

n, k = map(int, input().split())
p = list(map(int, input().split()))

minList = deque()
maxList = deque()
ascList = deque()


def add_list(_k, target):
    global p
    global minList
    global maxList
    global ascList
    while len(minList) > 0 and p[minList[-1]] >= p[target]:
        minList.pop()
    minList.append(target)
    if minList[0] == target - _k:
        minList.popleft()
    while len(maxList) > 0 and p[maxList[-1]] <= p[target]:
        maxList.pop()
    maxList.append(target)
    if maxList[0] == target - _k:
        maxList.popleft()
    if target > 0 and p[target] < p[target-1]:
        ascList.append(target-1)
    if len(ascList) > 0 and ascList[0] == target - _k:
        ascList.popleft()


count = 0
ascend = 0
for i in range(k):
    add_list(k, i)

if len(ascList) == 0:
    ascend += 1
else:
    count += 1
for i in range(k, n):
    tail_is_max = False
    if p[i] > p[maxList[0]]:
        tail_is_max = True
    add_list(k, i)
    head_is_min = False
    if p[i-k] < p[minList[0]]:
        head_is_min = True
    if not (tail_is_max and head_is_min):
        if len(ascList) == 0:
            if ascend == 0:
                ascend += 1
        else:
            count += 1

print(count+ascend)

