In the official contest this problem has a different statement, for which jury's solution was working incorrectly, and for this reason it was excluded from the contest. This mistake have been fixed and the current given problem statement and model solution corresponds to what jury wanted it to be during the contest.

Vova and Lesha are friends. They often meet at Vova's place and compete against each other in a computer game named The Ancient Papyri: Swordsink. Vova always chooses a warrior as his fighter and Leshac chooses an archer. After that they should choose initial positions for their characters and start the fight. A warrior is good at melee combat, so Vova will try to make the distance between fighters as small as possible. An archer prefers to keep the enemy at a distance, so Lesha will try to make the initial distance as large as possible.

There are n (n is always even) possible starting positions for characters marked along the Ox axis. The positions are given by their distinct coordinates x_1, x_2, ..., x_{n}, two characters cannot end up at the same position.

Vova and Lesha take turns banning available positions, Vova moves first. During each turn one of the guys bans exactly one of the remaining positions. Banned positions cannot be used by both Vova and Lesha. They continue to make moves until there are only two possible positions remaining (thus, the total number of moves will be n - 2). After that Vova's character takes the position with the lesser coordinate and Lesha's character takes the position with the bigger coordinate and the guys start fighting.

Vova and Lesha are already tired by the game of choosing positions, as they need to play it before every fight, so they asked you (the developer of the The Ancient Papyri: Swordsink) to write a module that would automatically determine the distance at which the warrior and the archer will start fighting if both Vova and Lesha play optimally.


-----Input-----

The first line on the input contains a single integer n (2 ≤ n ≤ 200 000, n is even) — the number of positions available initially. The second line contains n distinct integers x_1, x_2, ..., x_{n} (0 ≤ x_{i} ≤ 10^9), giving the coordinates of the corresponding positions.


-----Output-----

Print the distance between the warrior and the archer at the beginning of the fight, provided that both Vova and Lesha play optimally.


-----Examples-----
Input
6
0 1 3 7 15 31

Output
7

Input
2
73 37

Output
36



-----Note-----

In the first sample one of the optimum behavior of the players looks like that:  Vova bans the position at coordinate 15;  Lesha bans the position at coordinate 3;  Vova bans the position at coordinate 31;  Lesha bans the position at coordinate 1. 

After these actions only positions 0 and 7 will remain, and the distance between them is equal to 7.

In the second sample there are only two possible positions, so there will be no bans.

Difficulty: HARD

Solutions:
n = int(input())
x = sorted(list(map(int, input().split())))
print(min([x[i + n // 2] - x[i] for i in range(n // 2)]))


def main():
	n = int(input())
	l = sorted(map(int, input().split()))
	print(min((b - a for (a, b) in zip(l, l[n // 2:]))))

def __starting_point():
	main()
__starting_point()


import os
import random
import sys
from typing import List, Dict

class Int:

	def __init__(self, val):
		self.val = val

	def get(self):
		return self.val + 111

class Unique:

	def __init__(self):
		self.s = set()

	def add(self, val: int):
		self.s.add(val)

	def __contains__(self, item: int) -> bool:
		return self.s.__contains__(item)

def ceil(top: int, bottom: int) -> int:
	return (top + bottom - 1) // bottom

def concat(l: List[int]):
	return ''.join(map(str, l))

def get(d: Dict[int, str], val: int) -> Dict[int, str]:
	return d[val]

def slowsolve(a):
	a.sort()
	small = True
	while len(a) > 2:
		if small:
			if a[1] - a[0] > a[-1] - a[-2]:
				a.pop(0)
			else:
				a.pop()
			small = False
		else:
			a.pop(len(a) // 2)
			small = True
	return a[1] - a[0]

def solve(a):
	a.sort()
	candelete = len(a) // 2 - 1
	res = 10 ** 18
	for leftdelete in range(0, candelete + 1):
		leftrem = leftdelete
		rightrem = leftdelete + candelete + 1
		res = min(res, a[rightrem] - a[leftrem])
	return res

def prt(l):
	return print(' '.join(l))

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

def rl(n):
	return [list(map(int, input().split())) for _ in range(n)]
if os.path.exists('test.txt'):
	sys.stdin = open('test.txt')
(n,) = rv()
(a,) = rl(1)
print(solve(a))


import os
import random
import sys

def slowsolve(a):
	a.sort()
	small = True
	while len(a) > 2:
		if small:
			if a[1] - a[0] > a[-1] - a[-2]:
				a.pop(0)
			else:
				a.pop()
			small = False
		else:
			a.pop(len(a) // 2)
			small = True
	return a[1] - a[0]

def solve(a):
	a.sort()
	candelete = len(a) // 2 - 1
	res = 10 ** 18
	for leftdelete in range(0, candelete + 1):
		leftrem = leftdelete
		rightrem = leftdelete + candelete + 1
		res = min(res, a[rightrem] - a[leftrem])
	return res

def prt(l):
	return print(' '.join(l))

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

def rl(n):
	return [list(map(int, input().split())) for _ in range(n)]
if os.path.exists('test.txt'):
	sys.stdin = open('test.txt')
(n,) = rv()
(a,) = rl(1)
print(solve(a))


n = int(input())
v = sorted([int(i) for i in input().split()])
ans = 2 ** 40
for i in range(n // 2):
	ans = min(ans, v[i + n // 2] - v[i])
print(ans)


from itertools import accumulate
m = int(input()) // 2
X = [int(x) for x in input().split()]
X.sort()
Z = [X[i + m] - X[i] for i in range(m)]
print(min(Z))