Reve has two integers $n$ and $k$.

Let $p$ be a permutation$^\dagger$ of length $n$. Let $c$ be an array of length $n - k + 1$ such that $$c_i = \max(p_i, \dots, p_{i+k-1}) + \min(p_i, \dots, p_{i+k-1}).$$ Let the cost of the permutation $p$ be the maximum element of $c$.

Koxia wants you to construct a permutation with the minimum possible cost.

$^\dagger$ A permutation of length $n$ is an array consisting of $n$ distinct integers from $1$ to $n$ in arbitrary order. For example, $[2,3,1,5,4]$ is a permutation, but $[1,2,2]$ is not a permutation ($2$ appears twice in the array), and $[1,3,4]$ is also not a permutation ($n=3$ but there is $4$ in the array).


-----Input-----

Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2000$) — the number of test cases. The description of test cases follows.

The first line of each test case contains two integers $n$ and $k$ ($1 \leq k \leq n \leq 2 \cdot 10^5$).

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


-----Output-----

For each test case, output $n$ integers $p_1,p_2,\dots,p_n$, which is a permutation with minimal cost. If there is more than one permutation with minimal cost, you may output any of them.


-----Examples-----

Input
3
5 3
5 1
6 6
Output
5 1 2 3 4
1 2 3 4 5
3 2 4 1 6 5


-----Note-----

In the first test case,

$c_1 = \max(p_1,p_2,p_3) + \min(p_1,p_2,p_3) = 5 + 1 = 6$.

$c_2 = \max(p_2,p_3,p_4) + \min(p_2,p_3,p_4) = 3 + 1 = 4$.

$c_3 = \max(p_3,p_4,p_5) + \min(p_3,p_4,p_5) = 4 + 2 = 6$.

Therefore, the cost is $\max(6,4,6)=6$. It can be proven that this is the minimal cost.

Difficulty: EASY

Solutions:
import sys

def solve():
	inp = sys.stdin.readline
	(n, m) = map(int, inp().split())
	a = [None] * n
	j = 1
	for i in range(m - 1, n, m):
		a[i] = j
		j += 1
	j = n
	for i in range(n):
		if a[i] is None:
			a[i] = j
			j -= 1
	print(' '.join(map(str, a)))

def main():
	for i in range(int(sys.stdin.readline())):
		solve()
main()


t = int(input(''))
for _ in range(t):
	(n, k) = [int(x) for x in input('').split(' ')]
	out = [0] * n
	low = 1
	high = n
	for i in range(n):
		if i % k == k - 1:
			out[i] = low
			low += 1
		else:
			out[i] = high
			high -= 1
	print(' '.join((str(x) for x in out)))


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	result = []
	max_val = n
	min_val = 1
	while len(result) < n:
		temp = 0
		while temp < k - 1 and len(result) < n:
			result.append(str(max_val))
			max_val -= 1
			temp += 1
		if len(result) < n:
			result.append(str(min_val))
			min_val += 1
	print(' '.join(result))


import heapq
import math
eps = 10 ** (-9)

def solve():
	(n, k) = input().split()
	(n, k) = (int(n), int(k))
	res = ''
	a = [x for x in range(1, n + 1)]
	i = 0
	j = n - 1
	for p in range(k - 1):
		res += ' ' + str(a[j])
		j -= 1
	res += ' ' + str(a[i])
	i += 1
	while i <= j:
		c = 0
		while i <= j and c < k - 1:
			res += ' ' + str(a[j])
			j -= 1
			c += 1
		if i <= j:
			res += ' ' + str(a[i])
			i += 1
	print(res[1:])
t = int(input())
for _ in range(t):
	solve()