package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

var (
	a       []int
	p       []int
	P_A     []int
	P_B     []int
	BIT     []int
	BIT_idx []int
	ans_l   []int
	ans_r   []int
	n, k    int
)

func check_M(v int) bool {
	p[0] = 0
	for i := 1; i <= n; i++ {
		if a[i] <= v {
			p[i] = p[i-1] + 1
		} else {
			p[i] = p[i-1] - 1
		}
	}
	min_P := int(1e9)
	for r := k; r <= n; r++ {
		l := r - k
		if p[l] < min_P {
			min_P = p[l]
		}
		if p[r]-min_P >= 0 {
			return true
		}
	}
	return false
}

func check_m(v int) bool {
	if v < 0 {
		return true
	}
	p[0] = 0
	for i := 1; i <= n; i++ {
		if a[i] <= v {
			p[i] = p[i-1] + 1
		} else {
			p[i] = p[i-1] - 1
		}
	}
	max_P := int(-1e9)
	for r := k; r <= n; r++ {
		l := r - k
		if p[l] > max_P {
			max_P = p[l]
		}
		if p[r]-max_P <= 0 {
			return true
		}
	}
	return false
}

func solve(L, R int) {
	if L > R {
		return
	}
	mid := L + (R-L)/2

	P_A[0] = 0
	P_B[0] = 0
	for i := 1; i <= n; i++ {
		if a[i] <= mid-1 {
			P_A[i] = P_A[i-1] + 1
		} else {
			P_A[i] = P_A[i-1] - 1
		}
		if a[i] <= mid {
			P_B[i] = P_B[i-1] + 1
		} else {
			P_B[i] = P_B[i-1] - 1
		}
	}

	best_l, best_r := -1, -1
	updates := make([]int, 0)

	for r := k; r <= n; r++ {
		l := r - k
		m_idx := 2*n + 2 - (P_A[l] + n + 1)
		for idx := m_idx; idx <= 2*n+2; idx += idx & -idx {
			if P_B[l] < BIT[idx] {
				BIT[idx] = P_B[l]
				BIT_idx[idx] = l
			}
		}
		updates = append(updates, m_idx)

		q_idx := 2*n + 2 - (P_A[r] + n + 1)
		min_B := int(1e9)
		opt_l := -1
		for idx := q_idx; idx > 0; idx -= idx & -idx {
			if BIT[idx] < min_B {
				min_B = BIT[idx]
				opt_l = BIT_idx[idx]
			}
		}

		if min_B <= P_B[r] {
			best_l = opt_l + 1
			best_r = r
			break
		}
	}

	for _, m_idx := range updates {
		for idx := m_idx; idx <= 2*n+2; idx += idx & -idx {
			BIT[idx] = 1e9
		}
	}

	sub := make([]int, best_r-best_l+1)
	copy(sub, a[best_l:best_r+1])
	sort.Ints(sub)
	m := len(sub)
	v1 := sub[(m-1)/2]
	v2 := sub[m/2]

	for v := max(L, v1); v <= min(R, v2); v++ {
		ans_l[v] = best_l
		ans_r[v] = best_r
	}

	solve(L, v1-1)
	solve(v2+1, R)
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buffer := make([]byte, 1024*1024)
	scanner.Buffer(buffer, 1024*1024*10)

	readInt := func() int {
		scanner.Scan()
		res := 0
		sign := 1
		for _, b := range scanner.Bytes() {
			if b == '-' {
				sign = -1
			} else {
				res = res*10 + int(b-'0')
			}
		}
		return res * sign
	}

	if !scanner.Scan() {
		return
	}
	t_str := scanner.Bytes()
	t := 0
	for _, b := range t_str {
		t = t*10 + int(b-'0')
	}

	maxN := 300005
	a = make([]int, maxN)
	p = make([]int, maxN)
	P_A = make([]int, maxN)
	P_B = make([]int, maxN)
	BIT = make([]int, 2*maxN+5)
	BIT_idx = make([]int, 2*maxN+5)
	ans_l = make([]int, maxN)
	ans_r = make([]int, maxN)

	for i := 0; i < len(BIT); i++ {
		BIT[i] = 1e9
	}

	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	for tc := 0; tc < t; tc++ {
		n = readInt()
		k = readInt()
		for i := 1; i <= n; i++ {
			a[i] = readInt()
		}

		low, high := 1, n
		v_min := n + 1
		for low <= high {
			mid := low + (high-low)/2
			if check_M(mid) {
				v_min = mid
				high = mid - 1
			} else {
				low = mid + 1
			}
		}

		low, high = 1, n
		v_max := 0
		for low <= high {
			mid := low + (high-low)/2
			if check_m(mid - 1) {
				v_max = mid
				low = mid + 1
			} else {
				high = mid - 1
			}
		}

		if v_min > v_max {
			fmt.Fprintln(out, 0)
			continue
		}

		solve(v_min, v_max)

		count := v_max - v_min + 1
		fmt.Fprintln(out, count)
		for v := v_min; v <= v_max; v++ {
			fmt.Fprintln(out, v, ans_l[v], ans_r[v])
		}
	}
}