On February 14 Denis decided to give Valentine to Nastya and did not come up with anything better than to draw a huge red heart on the door of the length $k$ ($k \ge 3$). Nastya was very confused by this present, so she decided to break the door, throwing it on the mountains.

Mountains are described by a sequence of heights $a_1, a_2, \dots, a_n$ in order from left to right ($k \le n$). It is guaranteed that neighboring heights are not equal to each other (that is, $a_i \ne a_{i+1}$ for all $i$ from $1$ to $n-1$).

Peaks of mountains on the segment $[l,r]$ (from $l$ to $r$) are called indexes $i$ such that $l < i < r$, $a_{i - 1} < a_i$ and $a_i > a_{i + 1}$. It is worth noting that the boundary indexes $l$ and $r$ for the segment are not peaks. For example, if $n=8$ and $a=[3,1,4,1,5,9,2,6]$, then the segment $[1,8]$ has only two peaks (with indexes $3$ and $6$), and there are no peaks on the segment $[3, 6]$.

To break the door, Nastya throws it to a segment $[l,l+k-1]$ of consecutive mountains of length $k$ ($1 \le l \le n-k+1$). When the door touches the peaks of the mountains, it breaks into two parts, after that these parts will continue to fall in different halves and also break into pieces when touching the peaks of the mountains, and so on. Formally, the number of parts that the door will break into will be equal to $p+1$, where $p$ is the number of peaks on the segment $[l,l+k-1]$.

Nastya wants to break it into as many pieces as possible. Help her choose such a segment of mountains $[l, l+k-1]$ that the number of peaks on it is maximum. If there are several optimal segments, Nastya wants to find one for which the value $l$ is minimal.

Formally, you need to choose a segment of mountains $[l, l+k-1]$ that has the maximum number of peaks. Among all such segments, you need to find the segment that has the minimum possible value $l$.


-----Input-----

The first line contains an integer $t$ ($1 \leq t \leq 10^4$)  — the number of test cases. Then the descriptions of the test cases follow.

The first line of each test case contains two integers $n$ and $k$ ($3 \leq k \leq n \leq 2 \cdot 10^5$)  — the number of mountains and the length of the door.

The second line of the input data set contains $n$ integers $a_1, a_2, \dots, a_n$ ($0 \leq a_i \leq 10 ^ 9$, $a_i \neq a_{i + 1}$)  — the heights of mountains.

It is guaranteed that the sum of $n$ over all the test cases will not exceed $2 \cdot 10^5$.


-----Output-----

For each test case, output two integers $t$ and $l$  — the maximum number of parts that the door can split into, and the left border of the segment of length $k$ that the door should be reset to.


-----Example-----
Input
5
8 6
1 2 4 1 2 4 1 2
5 3
3 2 3 2 1
10 4
4 3 4 3 2 3 2 1 0 1
15 7
3 7 4 8 2 3 4 5 21 2 3 4 2 1 3
7 5
1 2 3 4 5 6 1

Output
3 2
2 2
2 1
3 1
2 3



-----Note-----

In the first example, you need to select a segment of mountains from $2$ to $7$. In this segment, the indexes $3$ and $6$ are peaks, so the answer is $3$ (only $2$ peaks, so the door will break into $3$ parts). It is not difficult to notice that the mountain segments $[1, 6]$ and $[3, 8]$ are not suitable since they only have a $1$ peak (for the first segment, the $6$ index is not a peak, and for the second segment, the $3$ index is not a peak).

In the second example, you need to select a segment of mountains from $2$ to $4$. In this segment, the index $3$ is a peak, so the answer is $2$ (only $1$ peak, so the door will break into $2$ parts).

In the third example, you need to select a segment of mountains from $1$ to $4$. In this segment, the index $3$ is a peak, so the answer is $2$ (only $1$ peak, so the door will break into $2$ parts). You can see that on the segments $[2, 5]$, $[4, 7]$ and $[5, 8]$ the number of peaks is also $1$, but these segments have a left border greater than the segment $[1, 4]$, so they are not the correct answer.

Starter code:

Solutions:
for _ in range(int(input())):
    n, k = tuple(map(int, input().split()))
    arr = list(map(int, input().split()))

    peaks = [0 for i in range(n)]
    for i in range(1, n - 1):
        if arr[i] > arr[i - 1] and arr[i] > arr[i + 1]:
            peaks[i] = 1

    cnt = 0
    max_peaks = 0
    answer = 0

    for i in range(k - 1):
        cnt += peaks[i]
        max_peaks += peaks[i]

    for i in range(k - 1, n - 1):
        cnt -= peaks[i - k + 2]
        cnt += peaks[i]
        if cnt > max_peaks:
            max_peaks = cnt
            answer = i - k + 2

    print(max_peaks + 1, answer + 1)


from math import *
from random import *
for t in range(int(input())):
    n, k = map(int, input().split())
    mas = list(map(int, input().split()))
    pick = [0 for i in range(n)]
    for i in range(1, n - 1):
        pick[i] = pick[i - 1]
        if mas[i] > mas[i - 1] and mas[i] > mas[i + 1]:
            pick[i] += 1
    if n > 1:
        pick[n - 1] = pick[n - 2]
    mx = 0
    mxotv = 0
    for i in range(0, n - k + 1):
        if i + k - 2 < 0:
            continue
        res = pick[i + k - 2]
        res -= pick[i]
        if res > mx:
            mx = res
            mxotv = i
    print(mx + 1, mxotv + 1)

#list(map(int,input().split()))
t=int(input())
for _ in range(t):
    n,k=list(map(int,input().split()))
    aa=list(map(int,input().split()))
    tot=0
    ind=1
    
    for i in range(1,k-1):
        if(aa[i]>aa[i-1] and aa[i]>aa[i+1]):
            tot+=1
  #  print(tot)
    ma=tot+1
    for i in range(1,n):
        if(i+k-1>=n):
            continue
        if(aa[i]>aa[i-1] and aa[i]>aa[i+1]):
            tot-=1
        if(aa[i+k-2]>aa[i+k-3] and aa[i+k-2]>aa[i+k-1]):
            tot+=1
        if(tot+1>ma):
            ma=tot+1
            ind=i+1
      #  print(tot)
    print(ma,ind)
            
        
    


t = int(input())
for qq in range(t):
    n, k = list(map(int, input().split()))
    m = list(map(int, input().split()))
    p = 0
    for i in range(n - k + 1, n - 1):
        if m[i] > m[i - 1] and m[i] > m[i + 1]:
            p += 1
    mp = p
    ii = n - k + 1
    for i in range(n - k, 0, -1):
        if m[i] > m[i - 1] and m[i] > m[i + 1]:
            p += 1
        if m[i + k - 2] > m[i + k - 3] and m[i + k - 2] > m[i + k - 1]:
            p -= 1
        if p >= mp:
            mp = p
            ii = i
    print(mp + 1, ii)


t=int(input())
for _ in range(t):
    n,k=map(int,input().split())
    arr=list(map(int,input().split()))
    peaks=[0]*(n)
    for i in range(1,n-1):
        if arr[i]>arr[i-1] and arr[i]>arr[i+1]:
            peaks[i]=1
    acum=[0]
    for i in range(1,n):
        acum.append(acum[-1]+peaks[i])
    maxs=0
    pos=-1
    for i in range(n-k,-1,-1):
        tmp=acum[i+k-1]-acum[i]
        if peaks[i+k-1]==1:
            tmp-=1
        if tmp>=maxs:
            maxs=tmp
            pos=i
    print(maxs+1,pos+1)

from _collections import deque

for _ in range(int(input())):
    n, k = list(map(int, input().split()))
    ar = list(map(int, input().split()))
    picks = 0
    lol = deque([])
    for i in range(1, k - 1):
        if ar[i - 1] < ar[i] > ar[i + 1]:
            picks += 1
            lol.append(i)
    max_picks = picks
    ans = 0
    for i in range(k - 1, n - 1):
        if len(lol) > 0 and lol[0] == i - k + 2:
            lol.popleft()
            picks -= 1
        if ar[i - 1] < ar[i] > ar[i + 1]:
            picks += 1
            lol.append(i)
        if picks > max_picks:
            max_picks = picks
            ans = i - k + 2
    print(max_picks + 1, ans + 1)


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

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

for nt in range(int(input())):
	n,k=mult_input()
	l=list(map(int,input().split()))
	ans=0
	for i in range(1,k-1):
		if l[i]>l[i-1] and l[i]>l[i+1]:
			ans+=1
	ind=1
	i=1
	count=ans
	while i<n-k+1:
		if l[i]>l[i-1] and l[i]>l[i+1]:
			count-=1
		if l[i+k-2]>l[i+k-3] and l[i+k-2]>l[i+k-1]:
			count+=1
		if count>ans:
			ans=count
			ind=i+1
		i+=1
	print (ans+1,ind)

from collections import defaultdict as dd
def ri():
    return int(input())

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


def solve():
    n, k = rl()
    A = rl()
    peaks = []
    for i in range(1, n - 1):
        if A[i] > max(A[i - 1], A[i + 1]):
            peaks.append(1)
        else:
            peaks.append(0)

    best = sum(peaks[:k-2])
    curr = best
    best_l = 0
    for i in range(1, n - (k - 1)):
        curr -= peaks[i - 1]
        curr += peaks[i + k - 3]
        if curr > best:
            best = curr
            best_l = i
    return best + 1, best_l + 1



t = ri()
for i in range(t):
    print(*solve())


import sys
lines = sys.stdin.readlines()
# nums = lists(map(int, lines[0].strip().split(" ")))
T = int(lines[0].strip())
for t in range(T):
    (n, k) = list(map(int, lines[2*t+1].strip().split(" ")))
    nums = list(map(int, lines[2*t+2].strip().split(" ")))
    peaks = [0 for _ in range(n)]

    for i in range(1, n-1):
        if nums[i] > nums[i-1] and nums[i] > nums[i+1]: peaks[i] = 1
    for i in range(1, n):
        peaks[i] += peaks[i-1]
    maxP = -1
    maxIndex = -1
    for i in range(n-k+1):
        if peaks[i+k-2] - peaks[i] > maxP:
            maxP = peaks[i+k-2] - peaks[i]
            maxIndex = i
    print("{} {}".format(maxP+1, maxIndex+1))


import sys

input = sys.stdin.readline

for _ in range(int(input())):
    n, k = list(map(int, input().split()))
    a = list(map(int, input().split()))
    peak = [0] + [1 if a[i - 1] < a[i] and a[i] > a[i + 1] else 0 for i in range(1, n - 1)] + [0]
    b = [None] * (n - k + 1)
    b[0] = sum(peak[1 : k - 1])
    for i in range(1, n - k + 1):
        b[i] = b[i - 1] - peak[i] + peak[i + k - 2]
    p = max(b)    
    print(p + 1, b.index(p) + 1)


import sys
# from collections import defaultdict
# t=1
t=int(input())
for i in range(t):
    # n=int(input())
    # n,m=list(map(int,sys.stdin.readline().strip().split()))
    # a,b,c,d=list(sys.stdin.readline().strip().split())
    n,k=list(map(int,sys.stdin.readline().strip().split()))
    # if(n*(a+b)>=(c-d) and n*(a-b)<=(c+d)):
    #     print("YES")
    # else:
    #     print("NO")
    
    a=list(map(int,sys.stdin.readline().strip().split()))
    x=[0]*n
    for j in range(1,n-1):
        if(a[j]>a[j-1] and a[j]>a[j+1]):
            x[j]=1
    # print(a)
    # print(x)
    k=k-2
    op=0
    curr=0
    curr=sum(x[:k])
    # print(x)
    # print(curr)
    op=curr
    op1=1

    for j in range(k,n):
        # op=max(op,curr)
        curr=curr+x[j]-x[j-k]
        if(curr>op):
            # print("here")
            op1=j-k+1
            op=curr
        # op=max(op,curr)
    op=max(op,curr)
    print(op+1,op1)

t = int(input())
for ii in range(t):
    n, k = map(int, input().split())
    a = list(map(int, input().split()))
    p = [0] * n
    for i in range(1, n - 1):
        if a[i] > a[i - 1] and a[i] > a[i + 1]:
            p[i] = 1
    cur = 0
    ind = k - 1
    for i in range(k):
        if i != 0 and i != k - 1:
            cur += p[i]
    ans = cur
    ans_ind = k - 1
    while ind < n:
        if p[ind - k + 2]:
            cur -= 1
        if p[ind]:
            cur += 1
        if cur > ans:
            ans = cur
            ans_ind = ind + 1
        ind += 1
    print(ans + 1, ans_ind - k + 2)

t = int(input())
for i in range(t):
    n, k = list(map(int, input().split()))
    a = list(map(int, input().split()))
    cnt = 0
    for j in range(k):
        if 0 < j < k - 1 and a[j - 1] < a[j] > a[j + 1]:
            cnt += 1
    ans = cnt
    l = 0
    for j in range(n - k):
        if a[j + 2] < a[j + 1] > a[j]:
            cnt -= 1
        if a[j + k - 2] < a[j + k - 1] > a[j + k]:
            cnt += 1
        if cnt > ans:
            ans = cnt
            l = j + 1
    print(ans + 1, l + 1)