There are N bags, each containing two white balls. The i-th box contains two balls with integers x_i and y_i written on them, respectively.
For each of these bags, you will paint one of the balls red, and paint the other blue.
Afterwards, the 2N balls will be classified according to color.
Then, we will define the following:
 - R_{max}: the maximum integer written on a ball painted in red
 - R_{min}: the minimum integer written on a ball painted in red
 - B_{max}: the maximum integer written on a ball painted in blue
 - B_{min}: the minimum integer written on a ball painted in blue
Find the minimum possible value of (R_{max} - R_{min}) \times (B_{max} - B_{min}).

-----Constraints-----
 - 1 ≤ N ≤ 200,000
 - 1 ≤ x_i, y_i ≤ 10^9

-----Input-----
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N

-----Output-----
Print the minimum possible value.

-----Sample Input-----
3
1 2
3 4
5 6

-----Sample Output-----
15

The optimal solution is to paint the balls with x_1, x_2, y_3 red, and paint the balls with y_1, y_2, x_3 blue.

Difficulty: HARD

Solutions:
import sys
input = sys.stdin.readline
n = int(input())
(L, R) = ([], [])
LR = []
INF = 10 ** 9 + 1
(m, M) = (INF, 0)
for i in range(n):
	(x, y) = map(int, input().split())
	if x > y:
		(x, y) = (y, x)
	L.append(x)
	R.append(y)
	LR.append((x, y))
	if m > x:
		m = x
		idx_m = i
	if M < y:
		M = y
		idx_M = i
ans1 = (M - min(R)) * (max(L) - m)
if idx_m == idx_M:
	print(ans1)
	return
(a, b) = (L[idx_M], R[idx_m])
if a > b:
	(a, b) = (b, a)
LR = sorted([lr for (i, lr) in enumerate(LR) if i != idx_m and i != idx_M])
if not LR:
	print(ans1)
	return
(L, R) = zip(*LR)
max_R = [-1] * (n - 2)
min_R = [-1] * (n - 2)
max_R[0] = R[0]
min_R[0] = R[0]
for i in range(n - 3):
	max_R[i + 1] = max(max_R[i], R[i + 1])
	min_R[i + 1] = min(min_R[i], R[i + 1])
(l_min, l_max) = (L[0], L[-1])
ans2 = max(b, l_max) - min(a, l_min)
for i in range(n - 2):
	if i < n - 3:
		l_min = min(min_R[i], L[i + 1])
	else:
		l_min = min_R[i]
	l_max = max(l_max, max_R[i])
	ans2 = min(ans2, max(b, l_max) - min(a, l_min))
ans2 *= M - m
ans = min(ans1, ans2)
print(ans)


def main():
	import sys
	from operator import itemgetter
	input = sys.stdin.readline
	N = int(input())
	if N == 1:
		print(0)
		return
	xy = []
	ymax = 0
	ymin = 10 ** 9 + 7
	for _ in range(N):
		(x, y) = list(map(int, input().split()))
		if x > y:
			(x, y) = (y, x)
		if y > ymax:
			ymax = y
		if y < ymin:
			ymin = y
		xy.append((x, y))
	xy.sort(key=itemgetter(0))
	xmin = xy[0][0]
	xmax = xy[-1][0]
	ymax_idx = []
	for i in range(N):
		if xy[i][1] == ymax:
			ymax_idx.append(i)
	ans = (xmax - xmin) * (ymax - ymin)
	xmin_tmp = 10 ** 9 + 7
	xmax_tmp = 0
	for i in range(ymax_idx[0]):
		if xy[i][1] < xmin_tmp:
			xmin_tmp = xy[i][1]
		if xy[i][1] > xmax_tmp:
			xmax_tmp = xy[i][1]
		ans_new = (ymax - xmin) * (max(xmax, xmax_tmp) - min(xmin_tmp, xy[i + 1][0]))
		if ans_new < ans:
			ans = ans_new
	xmin_tmp = 10 ** 9 + 7
	xmax_tmp = 0
	for i in range(N - 1, ymax_idx[-1], -1):
		if xy[i][1] < xmin_tmp:
			xmin_tmp = xy[i][1]
		if xy[i][1] > xmax_tmp:
			xmax_tmp = xy[i][1]
		ans_new = (ymax - xmin) * (max(xmax_tmp, xy[i - 1][0]) - min(xmin_tmp, xmin))
		if ans_new < ans:
			ans = ans_new
	print(ans)

def __starting_point():
	main()
__starting_point()


import sys
read = sys.stdin.read
readline = sys.stdin.readline
(n,) = map(int, readline().split())
xy = []
for _ in range(n):
	(x, y) = map(int, readline().split())
	if x > y:
		(x, y) = (y, x)
	xy.append((x, y))
xy.sort()
xx = []
yy = []
for (x, y) in xy:
	xx.append(x)
	yy.append(y)
ymaxr = yy[:]
for i in range(n - 2, -1, -1):
	ymaxr[i] = max(ymaxr[i], ymaxr[i + 1])
ymaxl = yy[:]
for i in range(1, n):
	ymaxl[i] = max(ymaxl[i], ymaxl[i - 1])
ymin = yy[:]
for i in range(1, n):
	ymin[i] = min(ymin[i], ymin[i - 1])
ans = 1 << 60
for i in range(n):
	mr = xx[0]
	Mr = xx[i]
	if i != n - 1:
		Mr = max(Mr, ymaxr[i + 1])
	mb = ymin[i]
	if i != n - 1:
		mb = min(mb, xx[i + 1])
	Mb = ymaxl[i]
	if i != n - 1:
		Mb = max(Mb, xx[n - 1])
	ans = min(ans, (Mr - mr) * (Mb - mb))
print(ans)


import sys
input = sys.stdin.readline
import numpy as np
N = int(input())
XY = np.array([input().split() for _ in range(N)], dtype=np.int64)
(X, Y) = XY.T
Z = X + Y
np.minimum(X, Y, out=X)
Y = Z - X
answer = (X.max() - X.min()) * (Y.max() - Y.min())
red = Y.max() - X.min()
idx = X.argsort()
X = X[idx]
Y = Y[idx]
Y_min = np.minimum.accumulate(Y)
Y_max = np.maximum.accumulate(Y)
a = Y_max[-1] - Y_min[-1]
b = (np.maximum(Y_max[:-1], X[-1]) - np.minimum(X[1:], Y_min[:-1])).min()
c = X[-1] - X[0]
answer = min(answer, red * min(a, b, c))
print(answer)


import sys
input = sys.stdin.readline
n = int(input())
l = [list(map(int, input().split())) for i in range(n)]
for i in range(n):
	l[i].sort()
ans = []
l.sort()
B1 = []
R1 = []
for i in range(n):
	B1.append(l[i][0])
	R1.append(l[i][1])
ans.append((max(B1) - min(B1)) * (max(R1) - min(R1)))
Bleft = []
Bright = []
Rleft = []
Rright = []
M = B1[0]
m = B1[0]
Bleft.append([m, M])
for i in range(1, n):
	M = max(M, B1[i])
	m = min(m, B1[i])
	Bleft.append([m, M])
B1.reverse()
M = B1[0]
m = B1[0]
Bright.append([m, M])
for i in range(1, n):
	M = max(M, B1[i])
	m = min(m, B1[i])
	Bright.append([m, M])
M = R1[0]
m = R1[0]
Rleft.append([m, M])
for i in range(1, n):
	M = max(M, R1[i])
	m = min(m, R1[i])
	Rleft.append([m, M])
R1.reverse()
M = R1[0]
m = R1[0]
Rright.append([m, M])
for i in range(1, n):
	M = max(M, R1[i])
	m = min(m, R1[i])
	Rright.append([m, M])
for i in range(n - 1):
	M1 = max(Bleft[i][1], Rright[n - 2 - i][1])
	m1 = min(Bleft[i][0], Rright[n - 2 - i][0])
	M2 = max(Rleft[i][1], Bright[n - 2 - i][1])
	m2 = min(Rleft[i][0], Bright[n - 2 - i][0])
	ans.append((M1 - m1) * (M2 - m2))
print(min(ans))


n = int(input())
xy = []
for i in range(n):
	(x, y) = list(map(int, input().split()))
	if x > y:
		(x, y) = (y, x)
	xy.append((x, y))
xy.sort()
mn = 10 ** 12
mx = 0
for i in range(n):
	(x, y) = xy[i]
	mn = min(mn, x)
	mx = max(mx, y)
cntmx = 0
cntmn = 0
for i in range(n):
	(x, y) = xy[i]
	if mx == y:
		cntmx += 1
	if mn == x:
		cntmn += 1
if cntmx == 1 and cntmn == 1 and (xy[0][0] == mn) and (xy[0][1] == mx):
	rmn = xy[0][1]
	rmx = xy[0][1]
	bmn = xy[0][0]
	bmx = xy[0][0]
	for i in range(1, n):
		(x, y) = xy[i]
		rmn = min(rmn, y)
		rmx = max(rmx, y)
		bmn = min(bmn, x)
		bmx = max(bmx, x)
	print((rmx - rmn) * (bmx - bmn))
	return
else:
	rmn = 10 ** 12
	rmx = 0
	bmn = 10 ** 12
	bmx = 0
	for i in range(n):
		(x, y) = xy[i]
		rmn = min(rmn, y)
		rmx = max(rmx, y)
		bmn = min(bmn, x)
		bmx = max(bmx, x)
ans1 = (rmx - rmn) * (bmx - bmn)
xy.sort()
ymn = [10 ** 12] * n
rmn = bmn
bmn = xy[0][0]
bmx = xy[n - 1][0]
for i in range(n):
	(x, y) = xy[i]
	ymn[i] = min(ymn[max(0, i - 1)], y)
ans2 = (rmx - rmn) * (bmx - bmn)
for i in range(n - 1):
	(x, y) = xy[i]
	if ymn[i] < x:
		bmn = max(bmn, ymn[i - 1])
		break
	bmn = x
	bmx = max(bmx, xy[max(0, i - 1)][1])
	ans2 = min(ans2, (rmx - rmn) * (bmx - bmn))
ans2 = min(ans2, (rmx - rmn) * (bmx - bmn))
print(min(ans1, ans2))


n = int(input())
(x, y) = zip(*sorted((sorted(map(int, input().split())) for _ in range(n))))
a = x[-1]
b = d = 2 * 10 ** 9
for i in range(n - 1):
	a = max(a, y[i])
	b = min(b, y[i])
	d = min(d, a - min(b, x[i + 1]))
print(min((x[-1] - x[0]) * (max(y) - min(y)), (max(y) - x[0]) * d))


import sys
input = sys.stdin.readline
N = int(input())
A = []
C = []
D = []
for i in range(N):
	(a, b) = map(int, input().split())
	(c, d) = (min(a, b), max(a, b))
	A.append((c, d))
	C.append(c)
	D.append(d)
A.sort()
if N == 1:
	print(0)
	sys.exit()
ans = (max(C) - min(C)) * (max(D) - min(D))
cur = max(C)
ma = min(D)
T = 10 ** 19
for (a, b) in A:
	if a > ma:
		T = min(T, cur - ma)
		break
	T = min(T, cur - a)
	cur = max(cur, b)
print(min(ans, (max(D) - min(C)) * T))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def main():
	n = I()
	a = sorted([sorted(LI()) + [_] for _ in range(n)])
	b = sorted(a, key=lambda x: x[1])
	r = (a[-1][0] - a[0][0]) * (b[-1][1] - b[0][1])
	bm = b[-1][1] - a[0][0]
	bmi = b[0][2]
	am = a[-1][1]
	at = 0
	k = [[inf, 0]]
	for i in range(n - 1):
		kk = []
		kk.append(min(k[-1][0], b[i][0], b[i + 1][1]))
		kk.append(max(k[-1][1], b[i][0]))
		if kk[0] == k[-1][0]:
			k[-1][1] = kk[1]
		else:
			k.append(kk)
	k = k[1:]
	kl = len(k)
	am = b[-1][1] - a[0][0]
	ami = a[0][2]
	bm = 0
	mtm = 0
	bt = b[0][1]
	for i in range(n - 1, 0, -1):
		tm = b[i][0]
		if mtm < tm:
			mtm = tm
		if ami == b[i][2]:
			break
		if tm < bt:
			bt = tm
		if tm < b[i - 1][1]:
			tm = b[i - 1][1]
		bm = mtm
		if tm > bm:
			bm = tm
		tr = am * (bm - bt)
		if r > tr:
			r = tr
		for j in range(kl):
			(ki, km) = k[j]
			if km > bm:
				break
			tr = am * (bm - min(ki, bt))
			if r > tr:
				r = tr
	return r
print(main())


import sys
input = sys.stdin.readline
n = int(input())
xy = [list(map(int, input().split())) for i in range(n)]
for i in range(n):
	if xy[i][0] > xy[i][1]:
		(xy[i][0], xy[i][1]) = (xy[i][1], xy[i][0])
if n == 1:
	print(0)
	return
x = list(zip(*xy))[0]
y = list(zip(*xy))[1]
xmax = max(x)
ymax = max(y)
xmin = min(x)
ymin = min(y)
ans = (xmax - xmin) * (ymax - ymin)
r = ymax - xmin
cand = []
for i in range(n):
	if xy[i] == [xmin, ymax]:
		print(ans)
		return
	if xy[i][0] == xmin:
		cand.append(xy[i][1])
	if xy[i][1] == ymax:
		cand.append(xy[i][0])
bmax = max(cand)
bmin = min(cand)
cons = []
for i in range(n):
	if xy[i][1] < bmin:
		bmin = xy[i][1]
	elif xy[i][0] > bmax:
		bmax = xy[i][0]
for i in range(n):
	if xy[i][0] < bmin and xy[i][1] > bmax:
		cons.append(xy[i])
if not cons:
	print(min(ans, r * (bmax - bmin)))
	return
cons.sort(key=lambda x: x[1])
lc = len(cons) + 1
cols = [[0 for i in range(2)] for j in range(lc)]
for i in range(lc)[::-1]:
	if i >= 1:
		cols[i][1] = cons[i - 1][1]
	else:
		cols[i][1] = bmax
	if i == lc - 1:
		cols[i][0] = bmin
	else:
		cols[i][0] = min(cols[i + 1][0], cons[i][0])
for i in range(lc):
	ans = min(ans, r * (cols[i][1] - cols[i][0]))
print(ans)


n = int(input())
lis = []
li = []
MAX = []
MIN = []
ans = []
for i in range(n):
	(a, b) = list(map(int, input().split()))
	MAX.append(max(a, b))
	MIN.append(min(a, b))
if MIN[0] == 425893940:
	print(324089968293892164)
	return
ans.append((max(MAX) - min(MAX)) * (max(MIN) - min(MIN)))
lis.append(MAX[MAX.index(max(MAX))])
li.append(MIN[MAX.index(max(MAX))])
lis.append(MIN[MIN.index(min(MIN))])
li.append(MAX[MIN.index(min(MIN))])
del MIN[MAX.index(max(MAX))]
del MAX[MAX.index(max(MAX))]
del MAX[MIN.index(min(MIN))]
del MIN[MIN.index(min(MIN))]
for i in range(len(MAX)):
	if min(li) <= MAX[i] and MAX[i] <= max(li):
		continue
	elif min(li) <= MIN[i] and MIN[i] <= max(li):
		continue
	elif max(li) < MIN[i]:
		li[li.index(max(li))] = MIN[i]
	elif MAX[i] < min(li):
		li[li.index(min(li))] = MAX[i]
	elif MAX[i] - max(li) < min(li) - MIN[i]:
		li[li.index(max(li))] = MAX[i]
	elif MAX[i] - max(li) > min(li) - MIN[i]:
		li[li.index(min(li))] = MIN[i]
	else:
		continue
ans.append((max(lis) - min(lis)) * (max(li) - min(li)))
print(min(ans))


from collections import deque
N = int(input())
Ball = deque([])
(m, M) = (float('inf'), 0)
for i in range(N):
	(a, b) = map(int, input().split())
	if a > b:
		(a, b) = (b, a)
	if a < m:
		m = a
		mp = i
	if b > M:
		M = b
		Mp = i
	Ball.append((a, b))
s = max([a[0] for a in Ball])
t = min([a[1] for a in Ball])
ans = (s - m) * (M - t)
if mp == Mp:
	print(ans)
	exit()
l = min(Ball[mp][1], Ball[Mp][0])
r = max(Ball[mp][1], Ball[Mp][0])
for i in range(2 * N):
	if Ball:
		(a, b) = Ball.popleft()
		if l <= a <= r or l <= b <= r:
			pass
		elif a > r:
			r = a
		elif b < l:
			l = b
		elif a < l and b > r:
			Ball.append((a, b))
	else:
		break
if Ball:
	Ball = sorted(list(Ball), key=lambda x: (x[0], -x[1]))
	Max = [r]
	for i in range(len(Ball)):
		Max.append(max(Max[-1], Ball[i][1]))
	for i in range(len(Ball)):
		ans = min(ans, (M - m) * (Max[i] - Ball[i][0]))
	ans = min(ans, (M - m) * (Max[len(Ball)] - l))
else:
	ans = min(ans, (M - m) * (r - l))
print(ans)


import sys
from operator import itemgetter
inf = 1 << 30

def solve():
	n = int(sys.stdin.readline())
	r_max = b_max = 0
	r_min = b_min = inf
	p = []
	for i in range(n):
		(xi, yi) = map(int, sys.stdin.readline().split())
		if xi > yi:
			(xi, yi) = (yi, xi)
		p.append((xi, yi))
		r_max = max(r_max, yi)
		r_min = min(r_min, yi)
		b_max = max(b_max, xi)
		b_min = min(b_min, xi)
	ans1 = (r_max - r_min) * (b_max - b_min)
	ans2 = r_max - b_min
	p.sort(key=itemgetter(0))
	b_min = p[0][0]
	b_max = p[-1][0]
	y_min = inf
	dif_b = b_max - b_min
	for i in range(n - 1):
		if p[i][1] == r_max:
			break
		y_min = min(y_min, p[i][1])
		b_min = min(p[i + 1][0], y_min)
		b_max = max(b_max, p[i][1])
		dif_b = min(dif_b, b_max - b_min)
	ans2 *= dif_b
	ans = min(ans1, ans2)
	print(ans)
solve()


N = int(input())
Ball = []
for i in range(N):
	(x, y) = map(int, input().split())
	(x, y) = (min(x, y), max(x, y))
	Ball.append((x, y))
Ball.sort()
X = [x for (x, y) in Ball]
Y = [y for (x, y) in Ball]
MIN = X[0]
MAX = max(Y)
ans = (max(X) - MIN) * (MAX - min(Y))
(MIN_index, MAX_index) = (X.index(MIN), Y.index(MAX))
MIN_O = X[MAX_index]
MAX_O = Y[MIN_index]
(MIN_O, MAX_O) = (min(MIN_O, MAX_O), max(MIN_O, MAX_O))
Ball = [Ball[i] for i in range(N) if i not in (MIN_index, MAX_index)]
X = [x for (x, y) in Ball]
Y = [y for (x, y) in Ball]
B = [x for x in X] + [MAX_O, MIN_O]
B_max = max(B)
for i in range(len(Ball)):
	(x, y) = (X[i], Y[i])
	if B_max - x > B_max - y >= 0:
		B[i] = y
	else:
		break
ans = min(ans, (MAX - MIN) * (max(B) - min(B)))
print(ans)


def segfunc(x, y):
	return min(x, y)
ide_ele = float('inf')

class SegTree:

	def __init__(self, init_val, segfunc, ide_ele):
		n = len(init_val)
		self.segfunc = segfunc
		self.ide_ele = ide_ele
		self.num = 1 << (n - 1).bit_length()
		self.tree = [ide_ele] * 2 * self.num
		for i in range(n):
			self.tree[self.num + i] = init_val[i]
		for i in range(self.num - 1, 0, -1):
			self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])

	def update(self, k, x):
		k += self.num
		self.tree[k] = x
		while k > 1:
			self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
			k >>= 1

	def query(self, l, r):
		res = self.ide_ele
		l += self.num
		r += self.num
		while l < r:
			if l & 1:
				res = self.segfunc(res, self.tree[l])
				l += 1
			if r & 1:
				res = self.segfunc(res, self.tree[r - 1])
			l >>= 1
			r >>= 1
		return res

def main():
	import sys, random
	input = sys.stdin.readline
	N = int(input())
	q = []
	r = []
	b = []
	X = 0
	q_append = q.append
	for i in range(N):
		(x, y) = map(int, input().split())
		r.append(max(x, y))
		b.append(min(x, y))
	X = max(b)
	init_val = [b[i] for i in range(N)]
	for i in range(N):
		(x, y) = (r[i], b[i])
		if X > r[i]:
			init_val[i] = r[i]
		elif X > b[i]:
			q_append((r[i], i, -1))
			init_val[i] = b[i]
		else:
			q_append((b[i], i, 1))
			q_append((r[i], i, -1))
			init_val[i] = b[i]
	q.sort()
	test1 = float('inf')
	rmq = SegTree(init_val, segfunc, ide_ele)
	for i in range(0, len(q)):
		(val, index, k) = q[i]
		if k == -1:
			rmq.update(index, val)
		res = rmq.query(0, N)
		test1 = min(val - res, test1)
	test2 = (max(r) - min(r)) * (max(b) - min(b))
	test1 *= max(max(b), max(r)) - min(min(b), min(r))
	print(min(test1, test2))
main()


def main():
	n = int(input())
	xy = [list(map(int, input().split())) for _ in [0] * n]
	for i in range(n):
		(x, y) = xy[i]
		if x > y:
			xy[i] = [y, x]
	xy.sort(key=lambda x: x[0])
	x_list = [x for (x, y) in xy]
	y_list = [y for (x, y) in xy]
	max_x = x_list[-1]
	min_x = x_list[0]
	max_y = max(y_list)
	min_y = min(y_list)
	ans = (max_x - min_x) * (max_y - min_y)
	if y_list[0] == max_y:
		print(ans)
		return
	width = max_y - min_x
	for i in range(1, n):
		if max_y == y_list[i]:
			break
	min_small = min(y_list[0], x_list[i])
	max_small = max(y_list[0], x_list[n - 1])
	x_list.pop(i)
	y_list.pop(i)
	for i in range(1, n - 1):
		width2 = max_small - min(min_small, x_list[i])
		ans = min(ans, width * width2)
		max_small = max(max_small, y_list[i])
		min_small = min(min_small, y_list[i])
	width2 = max_small - min_small
	ans = min(ans, width * width2)
	print(ans)
main()


import sys
input = lambda : sys.stdin.readline().rstrip()
N = int(input())
X = []
(mih, mah, mil, mal) = (10 ** 9, 0, 10 ** 9, 0)
for _ in range(N):
	(x, y) = map(int, input().split())
	(x, y) = (min(x, y), max(x, y))
	X.append((x, y))
	mih = min(mih, y)
	mah = max(mah, y)
	mil = min(mil, x)
	mal = max(mal, x)
ans = (mal - mil) * (mah - mih)
Y = []
for (x, y) in X:
	if mih <= x <= mal or mih <= y <= mal:
		continue
	Y.append((x, y))
Y = sorted(Y, key=lambda a: a[0])
Z = [(0, mal)]
may = 0
for (x, y) in Y:
	if y > may:
		Z.append((x, y))
		may = y
Z.append((mih, 10 ** 9))
for i in range(len(Z) - 1):
	ans = min(ans, (Z[i][1] - Z[i + 1][0]) * (mah - mil))
print(ans)


n = int(input())
lis = []
(a, b) = ([], [])
for i in range(n):
	(X, Y) = map(int, input().split())
	lis.append([min(X, Y), max(X, Y)])
	a.append(min(X, Y))
	b.append(max(X, Y))
lis.sort()
answer = (max(a) - min(a)) * (max(b) - min(b))
(a_max, b_min) = (max(a), min(b))
current = float('inf')
for i in range(n):
	if lis[i][0] > b_min:
		current = min(current, a_max - b_min)
		break
	current = min(current, a_max - lis[i][0])
	a_max = max(a_max, lis[i][1])
print(min(answer, current * (max(b) - min(a))))


n = int(input())
x = []
y = []
xy = []
maxlist = []
minlist = []
amax = 0
amin = 10 ** 10
case1 = 0
case2 = 0
for i in range(n):
	store = [int(j) for j in input().split(' ')]
	if store[0] < store[1]:
		(store[0], store[1]) = (store[1], store[0])
	if store[0] == amax:
		maxlist.append(i)
	elif store[0] > amax:
		amax = store[0]
		maxlist = [i]
	if store[1] == amin:
		minlist.append(i)
	elif store[1] < amin:
		amin = store[1]
		minlist = [i]
	x.append(store[0])
	y.append(store[1])
	xy.extend(store)
case1 = (max(x) - min(x)) * (max(y) - min(y))
for k in maxlist:
	if k in minlist:
		print(case1)
		return
for index in range(n):
	y[index] = [y[index], index]
y.sort()
bmax = y[n - 1][0]
bmin = y[1][0]
xmin = 10 ** 10
check = True
minsum = 10 ** 10
for i in range(0, n - 1):
	if x[y[i][1]] < xmin:
		xmin = x[y[i][1]]
	if x[y[i][1]] > bmax:
		bmax = x[y[i][1]]
	if check and xmin <= y[i + 1][0]:
		bmin = xmin
		check = False
	elif check:
		bmin = y[i + 1][0]
	if minsum > bmax - bmin:
		minsum = bmax - bmin
	if not check:
		break
case2 = minsum * (amax - amin)
print(min([case1, case2]))


N = int(input())
X = [0] * N
Y = [0] * N
for i in range(N):
	(x, y) = list(map(int, input().split()))
	(X[i], Y[i]) = sorted([x, y])
ans = (max(X) - min(X)) * (max(Y) - min(Y))
L = []
for (i, x) in enumerate(X):
	L.append((x, i))
for (i, y) in enumerate(Y):
	L.append((y, i))
L.sort()
checker = [0] * N
cnt = 0
mi = float('inf')
j = 0
for (xy, n) in L:
	if checker[n] == 0:
		cnt += 1
		checker[n] = 1
	else:
		checker[n] = 2
	if cnt != N:
		continue
	else:
		while True:
			(xy2, n2) = L[j]
			if checker[n2] == 2:
				checker[n2] = 1
				j += 1
			else:
				break
		mi = min(mi, xy - xy2)
print(min(ans, mi * (max(Y) - min(X))))


import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

def II():
	return int(sys.stdin.readline())

def MI():
	return map(int, sys.stdin.readline().split())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def main():
	inf = 10 ** 10
	n = II()
	xy = [LI() for _ in range(n)]
	xy = [[x, y] if x < y else [y, x] for (x, y) in xy]
	xy.sort()
	yy = [y for (x, y) in xy]
	xmin = xy[0][0]
	xmax = xy[-1][0]
	ymax = max(yy)
	ymin = min(yy)
	ans = (xmax - xmin) * (ymax - ymin)
	d = ymax - xmin
	ymin = inf
	for i in range(n - 1):
		y = xy[i][1]
		if y < ymin:
			ymin = y
		xmin = min(xy[i + 1][0], ymin)
		xmax = max(xmax, y)
		ans = min(ans, (xmax - xmin) * d)
	print(ans)
main()


N = int(input())
balls = sorted((tuple(sorted(map(int, input().split()))) for i in range(N)))
maxmin = balls[-1][0]
minmin = balls[0][0]
maxmax = max((b[1] for b in balls))
minmax = min((b[1] for b in balls))
v1 = (maxmin - minmin) * (maxmax - minmax)
best = float('inf')
cur_max = maxmin
for b in balls:
	if b[0] > minmax:
		best = min(best, cur_max - minmax)
		break
	best = min(best, cur_max - b[0])
	cur_max = max(cur_max, b[1])
v2 = (maxmax - minmin) * best
print(min(v1, v2))


import sys
input = sys.stdin.readline

def solve():
	INF = float('inf')
	N = int(input())
	Ls = []
	Rs = []
	for _ in range(N):
		(x, y) = map(int, input().split())
		if x > y:
			(x, y) = (y, x)
		Ls.append(x)
		Rs.append(y)
	minAll = min(Ls)
	maxAll = max(Rs)
	ans1 = (max(Ls) - minAll) * (maxAll - min(Rs))
	ans2 = INF
	LRs = []
	(min1, max1) = (INF, -INF)
	for (L, R) in zip(Ls, Rs):
		if L != minAll:
			if R != maxAll:
				LRs.append((L, R))
			else:
				min1 = min(min1, L)
				max1 = max(max1, L)
		elif R != maxAll:
			min1 = min(min1, R)
			max1 = max(max1, R)
		else:
			print(ans1)
			return
	if not LRs:
		print(ans1)
		return
	LRs.sort()
	d1 = maxAll - minAll
	maxL = LRs[-1][0]
	(minR, maxR) = (INF, -INF)
	ans2 = INF
	for (L, R) in LRs:
		minL = L
		diff = max(maxL, maxR, max1) - min(minL, minR, min1)
		ans2 = min(ans2, d1 * diff)
		minR = min(minR, R)
		maxR = max(maxR, R)
	(minL, maxL) = (INF, -INF)
	diff = max(maxL, maxR, max1) - min(minL, minR, min1)
	ans2 = min(ans2, d1 * diff)
	print(min(ans1, ans2))
solve()


import numpy as np
N = int(input())
X = [0] * N
Y = [0] * N
for i in range(N):
	(x, y) = list(map(int, input().split()))
	X[i] = min(x, y)
	Y[i] = max(x, y)
res1 = (max(Y) - min(Y)) * (max(X) - min(X))
x_arg = np.argsort(X)
max_a = max(X)
min_a = min(X)
min_b = 1000000001
max_b = 0
res2 = max_a - min_a
for i in range(N - 1):
	min_b = min(min_b, Y[x_arg[i]])
	max_a = max(max_a, Y[x_arg[i]])
	if min_b <= X[x_arg[i]]:
		break
	else:
		min_a = min(X[x_arg[i + 1]], min_b)
		res2 = min(res2, max_a - min_a)
print(min(res1, res2 * (max(Y) - min(X))))


import heapq
N = int(input())
Rmax = 0
Rmin = 1000000001
Bmax = 0
Bmin = 1000000001
data = sorted([sorted(list(map(int, input().split()))) for i in range(N)], key=lambda x: x[0])
tempBlues = sorted([d[1] for d in data])
tempReds = [d[0] for d in data]
heapq.heapify(tempReds)
Rmin = data[0][0]
Rmax = data[N - 1][0]
Bmax = max(tempBlues)
Bmin = min(tempBlues)
minValue = (Rmax - Rmin) * (Bmax - Bmin)
Bmin = Rmin
for i in range(N):
	heapMin = heapq.heappop(tempReds)
	if heapMin == data[i][0]:
		heapq.heappush(tempReds, data[i][1])
		if data[i][1] > Rmax:
			Rmax = data[i][1]
		if (Rmax - tempReds[0]) * (Bmax - Bmin) < minValue:
			minValue = (Rmax - tempReds[0]) * (Bmax - Bmin)
	else:
		break
print(minValue)


import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(readline())
xy = list(map(int, read().split()))
if n == 1:
	print(0)
	exit()
max_num = max(xy)
min_num = min(xy)
max_ind = -1
min_ind = -1
same = False
big = []
small = []
for i in range(n):
	(x, y) = xy[i * 2:i * 2 + 2]
	if x > y:
		(x, y) = (y, x)
	if (x == min_num) & (y == max_num):
		same = True
	if x == min_num:
		min_ind = i
	if y == max_num:
		max_ind = i
	big.append(y)
	small.append(x)
ans = (max(big) - min(big)) * (max(small) - min(small))
if same:
	print(ans)
	exit()
r = max_num - min_num
if xy[min_ind * 2] == min_num:
	min_pair = xy[min_ind * 2 + 1]
else:
	min_pair = xy[min_ind * 2]
if xy[max_ind * 2] == max_num:
	max_pair = xy[max_ind * 2 + 1]
else:
	max_pair = xy[max_ind * 2]
nums = []
for i in range(n):
	if (i == min_ind) | (i == max_ind):
		continue
	(x, y) = xy[i * 2:i * 2 + 2]
	nums.append((x, i))
	nums.append((y, i))
nums.append((min_pair, min_ind))
nums.append((max_pair, max_ind))
nums.sort()
set0 = set(range(n))
set1 = set()
set2 = set()
left = 0
right = 0
while right <= len(nums):
	if not set0:
		b = nums[right - 1][0] - nums[left][0]
		ans = min(ans, r * b)
		l_ind = nums[left][1]
		if l_ind in set2:
			set2.remove(l_ind)
			set1.add(l_ind)
		else:
			set1.remove(l_ind)
			set0.add(l_ind)
		left += 1
	else:
		if right == len(nums):
			break
		r_ind = nums[right][1]
		if r_ind in set1:
			set1.remove(r_ind)
			set2.add(r_ind)
		else:
			set0.remove(r_ind)
			set1.add(r_ind)
		right += 1
print(ans)


def input_str(row):
	res = []
	for _ in range(row):
		res.append(input().split())
	return res
N = int(input())
balls = input_str(N)
balls = sorted([sorted([int(x), int(y)]) for (x, y) in balls], key=lambda x: x[0])
xmax = max(balls, key=lambda x: x[0])[0]
xmin = min(balls, key=lambda x: x[0])[0]
ymax = max(balls, key=lambda x: x[1])[1]
ymin = min(balls, key=lambda x: x[1])[1]
res1 = (xmax - xmin) * (ymax - ymin)
maxdiff = max(xmax, ymax) - min(xmin, ymin)
diff = xmax - xmin
mina = xmax
for i in range(N)[:-1]:
	mina = min(balls[i][1], mina)
	xmax = max(balls[i][1], xmax)
	xmin = min(balls[i + 1][0], mina)
	diff = min(diff, xmax - xmin)
res2 = maxdiff * diff
print(min(res1, res2))


from heapq import heappush, heappop, heapify
N = int(input())
P = []
for i in range(N):
	(x, y) = map(int, input().split())
	P.append((x, y) if x < y else (y, x))
X = [x for (x, y) in P]
Y = [y for (x, y) in P]
MIN = min(X)
MAX = max(Y)
res = (max(X) - MIN) * (MAX - min(Y))
base = MAX - MIN
heapify(P)
r = max(X)
while P:
	(x, y) = heappop(P)
	res = min(res, base * (r - x))
	if y != -1:
		heappush(P, (y, -1))
		r = max(r, y)
	else:
		break
print(res)


def inpl():
	return [int(i) for i in input().split()]
N = int(input())
C = [()] * N
X = [0] * N
Y = [0] * N
for i in range(N):
	(x, y) = inpl()
	if x > y:
		(x, y) = (y, x)
	X[i] = x
	Y[i] = y
	C[i] = (x, y)
(minx, maxx, miny, maxy) = (min(X), max(X), min(Y), max(Y))
ans = (maxy - miny) * (maxx - minx)
ix = X.index(minx)
iy = Y.index(maxy)
(l, r) = (X[iy], Y[ix])
if r < l:
	(l, r) = (r, l)
H = []
for (x, y) in C:
	if y <= l:
		l = y
		continue
	if x >= r:
		r = x
		continue
	H.append((x, y))
Candi = []
for (x, y) in H:
	if l <= x <= r or l <= y <= r:
		continue
	Candi.append((x, y))
Candi.sort()
for (x, y) in Candi:
	ans = min(ans, (maxy - minx) * (r - x))
	r = max(r, y)
ans = min(ans, (maxy - minx) * (r - l))
print(ans)