Reminder: the median of the array $[a_1, a_2, \dots, a_{2k+1}]$ of odd number of elements is defined as follows: let $[b_1, b_2, \dots, b_{2k+1}]$ be the elements of the array in the sorted order. Then median of this array is equal to $b_{k+1}$.

There are $2n$ students, the $i$-th student has skill level $a_i$. It's not guaranteed that all skill levels are distinct.

Let's define skill level of a class as the median of skill levels of students of the class.

As a principal of the school, you would like to assign each student to one of the $2$ classes such that each class has odd number of students (not divisible by $2$). The number of students in the classes may be equal or different, by your choice. Every student has to be assigned to exactly one class. Among such partitions, you want to choose one in which the absolute difference between skill levels of the classes is minimized.

What is the minimum possible absolute difference you can achieve?


-----Input-----

Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1 \le t \le 10^4$). The description of the test cases follows.

The first line of each test case contains a single integer $n$ ($1 \le n \le 10^5$) — the number of students halved.

The second line of each test case contains $2n$ integers $a_1, a_2, \dots, a_{2 n}$ ($1 \le a_i \le 10^9$) — skill levels of students.

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


-----Output-----

For each test case, output a single integer, the minimum possible absolute difference between skill levels of two classes of odd sizes.


-----Example-----
Input
3
1
1 1
3
6 5 4 1 2 3
5
13 4 20 13 2 5 8 3 17 16

Output
0
1
5



-----Note-----

In the first test, there is only one way to partition students — one in each class. The absolute difference of the skill levels will be $|1 - 1| = 0$.

In the second test, one of the possible partitions is to make the first class of students with skill levels $[6, 4, 2]$, so that the skill level of the first class will be $4$, and second with $[5, 1, 3]$, so that the skill level of the second class will be $3$. Absolute difference will be $|4 - 3| = 1$.

Note that you can't assign like $[2, 3]$, $[6, 5, 4, 1]$ or $[]$, $[6, 5, 4, 1, 2, 3]$ because classes have even number of students.

$[2]$, $[1, 3, 4]$ is also not possible because students with skills $5$ and $6$ aren't assigned to a class.

In the third test you can assign the students in the following way: $[3, 4, 13, 13, 20], [2, 5, 8, 16, 17]$ or $[3, 8, 17], [2, 4, 5, 13, 13, 16, 20]$. Both divisions give minimal possible absolute difference.

Starter code:

Solutions:
for _ in range(int(input())):
    n = int(input())
    ar = list(map(int, input().split()))
    ar.sort()
    print(abs(ar[n] - ar[n - 1]))

t = int(input())
for _ in range(t):
    n = int(input())
    a = list(map(int, input().split()))
    a = sorted(a)
    print(a[n]- a[n - 1])

def iinput():
    return [int(x) for x in input().split()]


def main():
    n = int(input())
    data = iinput()
    data.sort()
    return abs(data[n] - data[n - 1])


for t in range(int(input())):
    print(main())

import sys

T = int(sys.stdin.readline().strip())
for t in range (0, T):
    n = int(sys.stdin.readline().strip())
    a = list(map(int, sys.stdin.readline().strip().split()))
    a.sort()
    print(a[n]-a[n-1])

import math, collections, sys
input = sys.stdin.readline
def case():
    n = int(input())
    a = list(map(int, input().split()))
    a.sort()
    print(a[n]-a[n-1])
for _ in range(int(input())):
    case()

for nt in range(int(input())):
	n=int(input())
	l=list(map(int,input().split()))
	if n==1:
		print (abs(l[0]-l[1]))
		continue
	l.sort()
	print (abs(l[n]-l[n-1]))

import math
for _ in range(int(input())):
    n=int(input())
    li=list(map(int,input().split()))
    li.sort()
    print(li[n]-li[n-1])

def main():
    import sys
    input = sys.stdin.readline

    t = int(input())
    for _ in range(t):
        N = int(input())
        A = list(map(int, input().split()))

        A.sort()
        print(A[N] - A[N-1])


def __starting_point():
    main()

__starting_point()

t=int(input())
for i in range(t):
  n=int(input())
  a=[int (i) for i in input().split()]
  a=sorted(a)
  print(a[n]-a[n-1])

import sys

# inf = open('input.txt', 'r')
# reader = (line.rstrip() for line in inf)
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__

t = int(input())
for _ in range(t):
    n = int(input())
    a = list(map(int, input().split()))
    a.sort()
    print(a[n] - a[n - 1])

# inf.close()


t = int(input())
for i in range(t):
    n = int(input())
    a = list(map(int,input().split()))
    a.sort()
    print(a[n]-a[n-1])

def solve():
    n = int(input())
    arr = sorted(map(int, input().split()))
    print(arr[n] - arr[n-1])


for _ in range(int(input())):
    solve()


for _ in range(int(input())):
    n = int(input())
    l1 = list(map(int, input().split()))
    l1.sort()
    print(l1[n] - l1[n-1])


def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		a = [int(i) for i in input().split()]
		a.sort()
		print(a[n] - a[n-1])

main()


def main():
    n = int(input())
    a = list(map(int, input().split()))
    a = sorted(a)
    print(a[len(a)//2] - a[len(a)//2 - 1])


def __starting_point():
    t = int(input())
    for i in range(t):
        main()
__starting_point()

for t in range(int(input())):
    n = int(input())
    a = sorted([int(i) for i in input().split()])
    print(a[n] - a[n-1])


for t in range(int(input())):
    n = int(input())
    l = [int(i) for i in input().split()]
    l.sort()
    print(abs(l[n] - l[n - 1]))


t=int(input())
for i in range(t):
    n=int(input())
    a=list(map(int,input().strip().split()))
    a.sort()
    print(a[n]-a[n-1])

def main():
    def solve():

        n = int(input())
        aa = [int(a) for a in input().split()]
        aa.sort()
        print(aa[n] - aa[n-1])

    q = int(input())
    for _ in range(q):
        solve()


def __starting_point():
    main()
__starting_point()

t = int(input())


for _ in range(t):
    n = int(input())

    a = list(map(int, input().split(' ')))

    a = sorted(a)

    print(a[len(a)//2] - a[len(a)//2-1])

t = int(input())
for _ in range(t):
    n = int(input())
    s = [int(x) for x in input().split()]
    s = sorted(s)
    print (abs(s[n]-s[n-1]))

t=int(input())
while t:
    n=int(input())
    a=input().split()
    for i in range(2*n):
        a[i]=int(a[i])
    a.sort()
    print(a[n]-a[n-1])
    t-=1

def solve(n, a_s):
    a_s.sort()
    return a_s[n] - a_s[n - 1]


def __starting_point():
    t = int(input())
    for _ in range(t):
        n = int(input())
        a_s = [int(ch) for ch in input().split(' ')]
        print(solve(n, a_s))

__starting_point()

for _ in range(int(input())):


    n = int(input())
    
    l = [int(i) for i in input().split()]
    
    l.sort(reverse=True)

    ind = 0

    P = []
    S = []
    
    for i in l:
        if (ind % 2) == 0:
            P.append(i)
        else:
            S.append(i)

        ind += 1
    
    
    if n % 2 == 0:
        a = abs(P[(n//2)-1] - S[n//2])
        b = abs(S[(n//2)-1] - P[n//2])
        print(min(a,b))
        
        
    else:
        print(abs(P[n//2] - S[n//2]))


for _ in range(int(input())):
	n=int(input())
	l=list(map(int,input().split()))
	l.sort()
	print(l[n]-l[n-1])


import sys
t = int(input())
for _ in range(t):
	n=int(input())
	l = list(map(int,sys.stdin.readline().split()))
	l.sort()
	print(l[n]-l[n-1])