Nian is a monster which lives deep in the oceans. Once a year, it shows up on the land, devouring livestock and even people. In order to keep the monster away, people fill their villages with red colour, light, and cracking noise, all of which frighten the monster out of coming.

Little Tommy has n lanterns and Big Banban has m lanterns. Tommy's lanterns have brightness a_1, a_2, ..., a_{n}, and Banban's have brightness b_1, b_2, ..., b_{m} respectively.

Tommy intends to hide one of his lanterns, then Banban picks one of Tommy's non-hidden lanterns and one of his own lanterns to form a pair. The pair's brightness will be the product of the brightness of two lanterns.

Tommy wants to make the product as small as possible, while Banban tries to make it as large as possible.

You are asked to find the brightness of the chosen pair if both of them choose optimally.


-----Input-----

The first line contains two space-separated integers n and m (2 ≤ n, m ≤ 50).

The second line contains n space-separated integers a_1, a_2, ..., a_{n}.

The third line contains m space-separated integers b_1, b_2, ..., b_{m}.

All the integers range from  - 10^9 to 10^9.


-----Output-----

Print a single integer — the brightness of the chosen pair.


-----Examples-----
Input
2 2
20 18
2 14

Output
252

Input
5 3
-1 0 1 2 3
-1 0 1

Output
2



-----Note-----

In the first example, Tommy will hide 20 and Banban will choose 18 from Tommy and 14 from himself.

In the second example, Tommy will hide 3 and Banban will choose 2 from Tommy and 1 from himself.

Source: codeforces | Difficulty: MEDIUM
Tags: Game theory

Complete search


Solutions:
(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
rec = [[] for i in range(n)]
INF = float('inf')
for i in range(n):
	for j in range(m):
		rec[i].append(a[i] * b[j])
	rec[i] = sorted(rec[i], reverse=True)
ma = [-INF] * n
ind = 0
for i in range(n):
	if ma < rec[i]:
		ma = rec[i]
		ind = i
mq = -INF
for i in range(n):
	if i == ind:
		continue
	mq = max(mq, max(rec[i]))
print(mq)


(n, m) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
s = []
for i in a:
	m = -10 ** 20
	for j in b:
		m = max(m, i * j)
	s.append(m)
s.sort()
print(s[-2])


(n, m) = map(int, input().split())
a1 = [int(x) for x in input().split()]
a2 = [int(x) for x in input().split()]
a1.sort()
a2.sort()
ans1 = -1e+18
ans2 = -1e+18
for i in range(len(a1) - 1):
	for j in a2:
		ans1 = max(ans1, a1[i] * j)
for i in range(1, len(a1)):
	for j in a2:
		ans2 = max(ans2, a1[i] * j)
print(int(min(ans1, ans2)))


inf = -10 ** 18
(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.sort(reverse=True)
if len(a) > 3:
	Max = [(a[0] * max(b), a[0] * min(b), 0 if 0 in b else inf), (a[1] * max(b), a[1] * min(b), 0 if 0 in b else inf), (0 if 0 in a else inf, 0 if 0 in a else inf), (a[len(a) - 2] * max(b), a[len(a) - 2] * min(b), 0 if 0 in b else inf), (a[len(a) - 1] * max(b), a[len(a) - 1] * min(b), 0 if 0 in b else inf)]
	MAX = [max(Max[0]), max(Max[1]), max(Max[2]), max(Max[3]), max(Max[4])]
else:
	Max = [list((j * i for i in b)) for j in a]
	MAX = [max(i) for i in Max]
MAX.sort(reverse=True)
print(MAX[1])


(n, m) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
big = 10 ** 25
small = -10 ** 25
first = []
for x in a:
	s = small
	for y in b:
		_ = x * y
		if _ > s:
			s = _
	first.append(s)
ans = big
for i in range(len(a)):
	s = small
	for j in range(len(a)):
		if j != i:
			if first[j] > s:
				s = first[j]
	if s < ans:
		ans = s
print(ans)


(n, m) = [int(i) for i in input().split(' ')]
A = [int(i) for i in input().split(' ')]
B = [int(i) for i in input().split(' ')]
C = []
maxval = A[0] * B[0]
ind = 0
ct = 0
for i in range(n):
	for j in range(m):
		if A[i] * B[j] > maxval:
			maxval = A[i] * B[j]
			ind = i
res = A[0] * B[0]
if ind == 0:
	res = A[1] * B[0]
for i in range(n):
	for j in range(m):
		if i != ind:
			res = max(res, A[i] * B[j])
print(res)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.sort(key=abs)
b.sort(key=abs)
maxi = -abs(a[-1] * b[-1]) - 1
I = 0
J = 0
for i in a:
	for j in b:
		o = max(maxi, i * j)
		if o != maxi:
			maxi = o
			I = i
			J = j
a.remove(I)
maxi = -abs(a[-1] * b[-1])
for i in a:
	for j in b:
		maxi = max(maxi, i * j)
print(maxi)


(n, m) = [int(i) for i in input().split()]
A = list(map(int, input().split()))
B = list(map(int, input().split()))
ans = []
A.sort()
B.sort()
if max(A[0] * B[-1], A[0] * B[0]) > max(A[-1] * B[-1], A[-1] * B[0]):
	A = A[1:]
else:
	A = A[:-1]
for i in A:
	for j in B:
		ans.append(i * j)
print(max(ans))


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans1 = 10 ** 18
for i in range(n):
	c = a[:i] + a[i + 1:]
	ans2 = -10 ** 18
	for j in c:
		for k in b:
			ans2 = max(j * k, ans2)
	ans1 = min(ans2, ans1)
print(ans1)


import copy
n = input()
a = [int(x) for x in input().split(' ')]
b = [int(x) for x in input().split(' ')]
best = 10000000000000000000000
for i in a:
	ahide = a.copy()
	ahide.remove(i)
	cand = -10000000000000000000000
	for x in ahide:
		for y in b:
			if x * y > cand:
				cand = x * y
	if cand < best:
		best = cand
print(best)


(n, m) = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
ans1 = float('inf')
for i in range(n):
	ans2 = -float('inf')
	for j in range(n):
		if j == i:
			continue
		for k in range(m):
			ans2 = max(ans2, A[j] * B[k])
	ans1 = min(ans1, ans2)
print(ans1)


(n, m) = map(int, input().split())
v1 = list(map(int, input().split()))
v2 = list(map(int, input().split()))
ans = []
for item in v1:
	temp = []
	for elt in v2:
		temp.append(item * elt)
	ans.append(max(temp))
ans.sort()
print(ans[-2])


from __future__ import division, print_function
MOD = 998244353
mod = 10 ** 9 + 7

def prepare_factorial():
	fact = [1]
	for i in range(1, 100005):
		fact.append(fact[-1] * i % mod)
	ifact = [0] * 100005
	ifact[100004] = pow(fact[100004], mod - 2, mod)
	for i in range(100004, 0, -1):
		ifact[i - 1] = i * ifact[i] % mod
	return (fact, ifact)
import sys
from bisect import bisect_left, bisect_right, insort
from math import floor, ceil, sqrt, degrees, atan, pi, log, sin, radians
from heapq import heappop, heapify, heappush
from collections import Counter, defaultdict, deque

def modinv(n, p):
	return pow(n, p - 2, p)

def ncr(n, r, fact, ifact):
	t = fact[n] * (ifact[r] * ifact[n - r]) % mod % mod
	return t

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

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

def input():
	return sys.stdin.readline().strip()

def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def lcm(x, y):
	return x * y // GCD(x, y)

def get_xor(n):
	return [n, 1, n + 1, 0][n % 4]

def fast_expo(a, b):
	res = 1
	while b:
		if b & 1:
			res = res * a
			res %= MOD
			b -= 1
		else:
			a = a * a
			a %= MOD
			b >>= 1
	res %= MOD
	return res

def get_n(P):
	ans = (-1 + sqrt(1 + 8 * P)) // 2
	return ans

def solve():
	(n, m) = map(int, input().split())
	a = [int(i) for i in input().split()]
	b = [int(i) for i in input().split()]
	ans = []
	for i in range(n):
		out = []
		for j in range(n):
			if i == j:
				continue
			for k in range(m):
				out.append(a[j] * b[k])
		ans.append(max(out))
	print(min(ans))
	return

def main():
	T = 1
	while T:
		solve()
		T -= 1
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
print(min([max([max([a[j] * k for k in b]) for j in range(n) if j != i]) for i in range(n)]))


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
b.sort()
low = b[0]
high = b[-1]
ans = []
for i in range(n):
	best = -10000000000000000000001
	for j in range(n):
		if i != j:
			best = max([best, low * a[j], a[j] * high])
	ans.append(best)
print(min(ans))


(n, m) = map(int, input().split())
l1 = list(map(int, input().split()))
l2 = list(map(int, input().split()))
ma = l1[0] * l2[0]
for i in range(len(l1)):
	for j in range(len(l2)):
		su = l1[i] * l2[j]
		if su >= ma:
			ma = su
			i1 = i
l3 = []
for i in range(len(l1)):
	if i == i1:
		continue
	for j in range(len(l2)):
		su = l1[i] * l2[j]
		l3.append(su)
print(max(l3))


(n, m) = input().split()
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans_g = 1 << 60
for i in range(len(a)):
	ans = 1 << 60
	ans = -ans
	for j in range(len(a)):
		if j != i:
			for k in range(len(b)):
				ans = max(ans, a[j] * b[k])
	ans_g = min(ans, ans_g)
print(ans_g)


(n, m) = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.sort()
b.sort()
max1 = max(a[0] * b[0], a[0] * b[-1])
max2 = max(a[-1] * b[-1], a[-1] * b[0])
if max1 > max2:
	a.pop(0)
else:
	a.pop()
max1 = max(a[0] * b[0], a[0] * b[-1])
max2 = max(a[-1] * b[-1], a[-1] * b[0])
print(max(max1, max2))


from copy import copy
(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
(x, y) = (0, 0)
A = copy(a)
A.remove(max(a))
x = max([max(A) * max(b), min(A) * min(b), max(A) * min(b), min(A) * max(b)])
A = copy(a)
A.remove(min(a))
y = max([max(A) * max(b), min(A) * min(b), max(A) * min(b), min(A) * max(b)])
print(min(x, y))


def first(num):
	return num[0]
(n, m) = map(int, input().split())
num = list(map(int, input().split()))
lst = list(map(int, input().split()))
pr = []
for i in range(n):
	for j in range(m):
		pr.append([num[i] * lst[j], num[i], lst[j]])
pr.sort(key=first)
pr.reverse()
num.pop(num.index(pr[0][1]))
ans = -100000000000000000000000000000
for i in range(n - 1):
	for j in range(m):
		if num[i] * lst[j] > ans:
			ans = num[i] * lst[j]
print(ans)


def main():
	(n, m) = [int(x) for x in input().split()]
	a = [int(x) for x in input().split()]
	b = [int(x) for x in input().split()]
	min_a = min(a)
	max_a = max(a)
	min_b = min(b)
	max_b = max(b)
	prod_with_min_a = max(min_a * min_b, min_a * max_b)
	prod_with_max_a = max(max_a * min_b, max_a * max_b)
	if prod_with_max_a > prod_with_min_a:
		a.remove(max_a)
		max_a = max(a)
	else:
		a.remove(min_a)
		min_a = min(a)
	print(max(min_a * min_b, min_a * max_b, max_a * min_b, max_a * max_b))
main()


import sys

def printf(format, *args):
	sys.stdout.write(format % args)
(n, m) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
ans = 10 ** 19
for i in range(n):
	act = -10 ** 19
	for j in range(m):
		for k in range(n):
			if k == i:
				continue
			act = max(act, a[k] * b[j])
	ans = min(ans, act)
print(ans)


(n, m) = map(int, input().split())
n_data = sorted(list(map(int, input().split())))
m_data = sorted(list(map(int, input().split())))
products = sorted([[n_data[i] * m_data[j], i] for i in range(n) for j in range(m)])
init = products[n * m - 1][1]
for i in range(n * m - 1, -1, -1):
	if products[i][1] != init:
		print(products[i][0])
		break


from operator import neg
(n, m) = map(int, input().split())
s1 = list(map(int, input().split()))
s2 = list(map(int, input().split()))
m = 0
tmp = -10 ** 18 - 1
for i in s1:
	for j in s2:
		if i * j > tmp:
			m = i
			tmp = i * j
s1.remove(m)
tmp = -10 ** 18 - 1
for i in s1:
	for j in s2:
		if i * j > tmp:
			m = i
			tmp = i * j
print(tmp)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
mn = 10 ** 18
for i in range(n):
	mx = -10 ** 18
	for j in range(n):
		if j == i:
			continue
		for k in range(m):
			mx = max(mx, a[j] * b[k])
	mn = min(mn, mx)
print(mn)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
d = list()
for i in a:
	c = -10 ** 50
	for j in b:
		c = max(c, i * j)
	d.append(c)
d.sort()
print(d[-2])


(n, m) = map(int, input().split())
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
d = {}
for i in a:
	if i not in d:
		d[i] = 0
	d[i] += 1
pair = []
for i in range(n):
	for j in range(m):
		pair.append([a[i], b[j]])
pair.sort(key=lambda x: x[0] * x[1])
i = -2
if d[pair[-1][0]] > 1:
	print(pair[-1][0] * pair[-1][1])
else:
	while pair[i][0] == pair[i + 1][0] and d[pair[i][0]] == 1:
		i -= 1
	print(pair[i][0] * pair[i][1])


(n, m) = [int(x) for x in input().split()]
ns = [int(x) for x in input().split()]
ms = [int(x) for x in input().split()]
maxi = -1000000000000000000
hide = None
for i in ns:
	for j in ms:
		if i * j > maxi:
			maxi = j * i
			hide = i
if hide in ns:
	ns.remove(hide)
maxi = -1000000000000000000
for i in ns:
	for j in ms:
		if i * j > maxi:
			maxi = j * i
print(maxi)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = float('inf')
for i in range(n):
	now = -float('inf')
	for j in range(n):
		if j != i:
			for k in range(m):
				now = max(now, a[j] * b[k])
	ans = min(ans, now)
print(ans)


from operator import itemgetter
a = input()
b = input().split(' ')
b = [int(i) for i in b]
c = input().split(' ')
c = [int(i) for i in c]
ans = []
for j in range(len(b)):
	for k in range(len(c)):
		ans.append([j, b[j] * c[k]])
ans = sorted(ans, key=itemgetter(1))
tmp = ans[-1][0]
ans = []
for j in range(len(b)):
	if j != tmp:
		for k in range(len(c)):
			ans.append(b[j] * c[k])
ans = sorted(ans)
print(ans[-1])


(n, m) = [int(x) for x in input().split()]
t = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
id = [max(t) * max(b), max(t) * min(b), min(t) * max(b), min(t) * min(b)]
if id.index(max(id)) > 1:
	t.remove(min(t))
else:
	t.remove(max(t))
print(max(max(t) * max(b), max(t) * min(b), min(t) * max(b), min(t) * min(b)))


from math import inf

def compability(lst1, lst2):
	lst3 = [-inf] * len(lst1)
	for i in range(len(lst1)):
		for j in range(len(lst2)):
			lst3[i] = max(lst3[i], lst1[i] * lst2[j])
	return sorted(lst3)[len(lst1) - 2]
(n, m) = [int(x) for x in input().split()]
a = [int(y) for y in input().split()]
b = [int(z) for z in input().split()]
print(compability(a, b))


(n, m) = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
m = 10 ** 19
for k in range(n):
	t = -10 ** 19
	for i in range(n):
		if i != k:
			if a[i] >= 0:
				t = max(max(b) * a[i], t)
			else:
				t = max(min(b) * a[i], t)
	m = min(t, m)
print(m)


(n, m) = [x for x in input().strip().split()]
N = [int(x) for x in input().strip().split()]
M = [int(x) for x in input().strip().split()]
lm = min(M)
ln = min(N)
hm = max(M)
hn = max(N)
maximum = max([ln * lm, ln * hm, lm * hn, hm * hn])
if maximum == ln * lm or maximum == ln * hm:
	N.remove(ln)
	ln = min(N)
else:
	N.remove(hn)
	hn = max(N)
print(max([ln * lm, ln * hm, lm * hn, hm * hn]))


from sys import stdin, stdout

def rint():
	return map(int, stdin.readline().split())
(n, m) = rint()
a = []
b = []
a = list(rint())
b = list(rint())
Max = -10 ** 1000
maxi = -1
for i in range(n):
	for j in range(m):
		if Max < a[i] * b[j]:
			Max = a[i] * b[j]
			maxi = i
Max = -10 ** 1000
for i in range(n):
	if i == maxi:
		continue
	for j in range(m):
		if Max < a[i] * b[j]:
			Max = a[i] * b[j]
print(Max)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans1 = 10 ** 18
for i in range(n):
	ans = -10 ** 18
	arr = a[:i] + a[i + 1:]
	for k in range(n - 1):
		for j in range(m):
			ans = max(ans, arr[k] * b[j])
	ans1 = min(ans1, ans)
print(ans1)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = sorted(map(int, input().split()))
mm = sorted((max(ai * b[0], ai * b[-1]) for ai in a))
mm.remove(max(mm))
print(max(mm))


pt = lambda *a, **k: print(*a, **k, flush=True)
rd = lambda : map(int, input().split())
(n, m) = rd()
an = list(rd())
bn = list(rd())
a1 = max(an)
a2 = min(an)
b1 = max(bn)
b2 = min(bn)
c1 = max(a1 * b1, a1 * b2)
c2 = max(a2 * b1, a2 * b2)
if c1 > c2:
	an.remove(a1)
else:
	an.remove(a2)
r = -4557430888798830399
for i in an:
	for j in bn:
		if i * j > r:
			r = i * j
pt(r)


(n, m) = input().split()
n = int(n)
m = int(m)
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.sort()
b.sort()
ans = 10000000000000000000
for i in range(n):
	maxi = -10000000000000000000
	for j in range(n):
		if j != i:
			for k in range(m):
				pr = a[j] * b[k]
				maxi = max(maxi, pr)
	ans = min(ans, maxi)
print(ans)


input()
a = list(map(int, input().split()))
b = list(map(int, input().split()))
print(min((max((x * y for x in a[:i] + a[i + 1:] for y in b)) for i in range(len(a)))))


input()
a = sorted([int(x) for x in input().split()])
b = sorted([int(x) for x in input().split()])
ans = []
for i in a:
	cur = []
	for ii in b:
		cur.append(ii * i)
	ans.append(max(cur))
print(sorted(ans)[-2])


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
r1 = 100000000000000000000
for restricted in range(n):
	r2 = -100000000000000000000
	for i in range(n):
		if i == restricted:
			continue
		for j in range(m):
			r2 = max(r2, a[i] * b[j])
	r1 = min(r1, r2)
print(r1)


(m, n) = map(int, input().split())
A = input()
a = A.split()
h = []
g = 0
k = []
for i in range(0, m):
	g = int(a[i])
	h.append(g)
B = input()
b = B.split()
for i in range(0, n):
	g = int(b[i])
	k.append(g)
h.sort()
k.sort()
s1 = max(max(h[1] * k[0], h[-1] * k[-1]), max(h[1] * k[-1], h[-1] * k[0]))
s2 = max(max(h[0] * k[0], h[-2] * k[-1]), max(h[0] * k[-1], h[-2] * k[0]))
ans = min(s1, s2)
print(ans)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
t1 = max(a)
t2 = min(a)
t3 = max(b)
t4 = min(b)
rt1 = max(t1 * t3, t1 * t4)
rt2 = max(t2 * t3, t2 * t4)
if rt1 > rt2:
	a.remove(t1)
	t1 = max(a)
else:
	a.remove(t2)
	t2 = min(a)
print(max(t1 * t3, t2 * t4, t1 * t4, t2 * t3))


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))

def MAX(a):
	ans = -float('inf')
	for i in b:
		for j in a:
			ans = max(ans, i * j)
	return ans
max_ = {i: -float('inf') for i in range(len(a))}
for i in range(len(a)):
	new_a = a[:i] + a[i + 1:]
	max_[i] = MAX(new_a)
print(min((i for i in max_.values())))


def main():
	(n, m) = [int(x) for x in input().split()]
	a = sorted([int(x) for x in input().split()])
	b = sorted([int(x) for x in input().split()])
	vv = max(a[0] * b[0], a[-1] * b[0], a[0] * b[-1], a[-1] * b[-1])
	if vv == a[0] * b[0] or vv == a[0] * b[-1]:
		a.pop(0)
	else:
		a.pop(-1)
	vv = max(a[0] * b[0], a[-1] * b[0], a[0] * b[-1], a[-1] * b[-1])
	print(vv)

def __starting_point():
	main()
__starting_point()


(a, b) = map(int, input().split())
c = list(map(int, input().split()))
d = list(map(int, input().split()))
x = []
for i in range(a):
	m = -10 ** 18
	for j in range(b):
		m = max(m, c[i] * d[j])
	x.append(m)
x.sort()
print(x[-2])


def solve():
	(N, M) = list(map(int, input().split()))
	T = list(map(int, input().split()))
	B = list(map(int, input().split()))
	res = []
	for n in range(N):
		for m in range(M):
			res.append([T[n] * B[m], n, m])
	res.sort(reverse=True)
	a = T[res[0][1]]
	T.remove(a)
	MAX = -1 * float('inf')
	for t in T:
		for b in B:
			MAX = max(t * b, MAX)
	print(int(MAX))

def __starting_point():
	solve()
__starting_point()


x = input().split()
a = int(x[0])
b = int(x[1])
Tom = [int(u) for u in input().split()]
Ben = [int(u) for u in input().split()]
Tom = sorted(Tom)
Ben = sorted(Ben)
s = []
for i in range(len(Tom)):
	Tom_linshi = Tom[0:i] + Tom[i + 1:len(Tom)]
	s.append(max([n * m for m in Tom_linshi for n in Ben]))
light = int(min(s))
print(light)


kk = lambda : map(int, input().split())
k2 = lambda : map(lambda x: int(x) - 1, input().split())
ll = lambda : list(kk())
(n, m) = kk()
(tt, bb) = (ll(), ll())
fb = sb = 0
maxi = a = b = 0
for i in range(n):
	for j in range(m):
		if i == 0 and j == 0 or tt[i] * bb[j] > maxi:
			(maxi, a, b) = (tt[i] * bb[j], i, j)
(maxi, fst) = (0, True)
for i in range(n):
	if i == a:
		continue
	for j in range(m):
		if fst or tt[i] * bb[j] > maxi:
			(fst, maxi) = (False, tt[i] * bb[j])
print(maxi)


(n, m) = map(int, input().split())
a = sorted(list(map(int, input().split())))
b = sorted(list(map(int, input().split())))

def getscore(a, b):
	return max((x * y for x in a for y in b))
print(min((getscore(a[:i] + a[i + 1:], b) for i in range(len(a)))))


(n, m) = map(int, input().split())
a = input().split()
b = input().split()
s = []
aa = []
for i in range(len(a)):
	a[i] = int(a[i])
for i in range(len(b)):
	b[i] = int(b[i])
for i in range(n):
	for l in range(m):
		s.append(a[i] * b[l])
		aa.append(i)
su = -10000000000000000000
for i in range(len(s)):
	if su < s[i]:
		su = s[i]
		n = aa[i]
while True:
	try:
		del s[aa.index(n)]
		del aa[aa.index(n)]
	except:
		break
s.sort()
print(s[-1])


def main():
	(n, m) = list(map(int, input().split()))
	t = list(map(int, input().split()))
	b = list(map(int, input().split()))
	maxs = []
	for ex in range(len(t)):
		maxs.append(max((x * y for (i, x) in enumerate(t) for y in b if i != ex)))
	print(min(maxs))
main()


import sys
f = sys.stdin
(m, n) = (int(number) for number in f.readline().split())
b = [int(number) for number in f.readline().split()]
a = [int(number) for number in f.readline().split()]
b.sort()
a.sort()
mx = a[0] * b[0]
if mx < a[n - 1] * b[m - 1]:
	mx = max(mx, a[n - 1] * b[m - 2])
else:
	mx = max(a[0] * b[1], a[n - 1] * b[m - 1])
if mx < 0:
	if a[0] > 0:
		mx = a[0] * b[m - 2]
	else:
		mx = a[n - 1] * b[1]
print(mx)


(n, m) = map(int, input().split())
l1 = list(map(int, input().split()))
l2 = list(map(int, input().split()))
ans1 = []
for i in range(n):
	ans = -10 ** 18 - 1
	for j in range(n):
		if j != i:
			for q in range(m):
				if ans < l1[j] * l2[q]:
					ans = l1[j] * l2[q]
	ans1.append(ans)
print(min(ans1))


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
kek = 1000000000000000000
for i in range(n):
	l = 0
	ti = -1000000000000000000
	for j in range(n):
		if j == i:
			continue
		for k in range(m):
			ti = max(a[j] * b[k], ti)
	kek = min(kek, ti)
print(kek)


(n, m) = map(int, input().split())
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
c = []
for i in range(n):
	for j in range(m):
		c.append([a[i] * b[j], i, j])
c = sorted(c)
x = c[-1][1]
while c[-1][1] == x:
	del c[-1]
print(c[-1][0])


class Solution:

	def resolve(self, n, m, a, b):
		prod = [0] * n
		for (i, ai) in enumerate(a):
			mm = ai * b[0]
			for bi in b:
				mm = max(mm, ai * bi)
			prod[i] = mm
		prod.sort()
		return prod[-2]

def __starting_point():
	s = Solution()
	(n, m) = list(map(int, input().split()))
	a = list(map(int, input().split()))
	b = list(map(int, input().split()))
	re = s.resolve(n, m, a, b)
	print(re)
__starting_point()


(m, n) = map(int, input().strip().split(' '))
a = list(map(int, input().strip().split(' ')))
b = list(map(int, input().strip().split(' ')))
a.sort()
b.sort()
if b[0] >= 0:
	a = a[:-1]
elif b[-1] <= 0:
	a = a[1:]
elif a[-1] * b[-1] > a[0] * b[0]:
	a = a[:-1]
else:
	a = a[1:]
if a[0] >= 0:
	bfinal = max(a[-1] * b[-1], a[0] * b[-1])
elif a[-1] <= 0:
	bfinal = max(a[0] * b[0], a[-1] * b[0])
else:
	bfinal = max(a[-1] * b[-1], a[0] * b[0])
print(bfinal)


def main():
	(n, m) = map(int, input().split())
	tommy = list(map(int, input().split()))
	banban = list(map(int, input().split()))
	min_prod = float('inf')
	for i in range(n):
		prod = -1 * float('inf')
		for j in range(n):
			if i != j:
				for k in range(m):
					prod = max(prod, banban[k] * tommy[j])
		min_prod = min(prod, min_prod)
	print(min_prod)
main()


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a = sorted(a)
b = sorted(b)
l = [a[0] * b[0], a[0] * b[-1], a[1] * b[0], a[1] * b[-1], a[-1] * b[0], a[-1] * b[-1], a[-2] * b[0], a[-2] * b[-1]]
if n == 2:
	l = l[:4]
elif n == 3:
	l.pop(-1)
	l.pop(-1)
ind = l.index(max(l)) // 2 * 2
l.pop(ind)
l.pop(ind)
print(max(l))


(n, m) = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
d = []
x = 0
a.sort()
b.sort()
for t in range(n):
	if a[t] > 0:
		d.append(a[t] * b[-1])
	else:
		d.append(a[t] * b[0])
d.sort()
print(d[-2])


input()
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.sort()
b.sort()
if a[-1] * b[-1] > max(a[0] * b[0], a[0] * b[-1]) or a[-1] * b[0] > max(a[0] * b[0], a[0] * b[-1]):
	a.pop()
else:
	a.pop(0)
print(max(a[0] * b[0], a[0] * b[-1], a[-1] * b[-1], a[-1] * b[0]))


def main():
	(n, m) = list(map(int, input().split()))
	l = list(map(int, input().split()))
	x = list(map(int, input().split()))
	m = {}
	for i in l:
		for j in x:
			m[i, j] = i * j
	c = -99798789896868767678678687687
	for i in m:
		if m[i] > c:
			c = m[i]
			y = i[0]
	l.remove(y)
	c = -99798789896868767678678687687
	for i in l:
		for j in x:
			c = max(c, i * j)
	print(c)
main()


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
(x, y) = (max(b), min(b))
result = 100000000000000000000000
for (i, item) in enumerate(a):
	lst = a[:i] + a[i + 1:]
	(mn, mx) = (100000000000000000000000, -100000000000000000000000)
	for (i, numb) in enumerate(lst):
		if mn > numb:
			mn = numb
		if mx < numb:
			mx = numb
	res = max(mn * x, mn * y, mx * x, mx * y)
	if res < result:
		result = res
print(result)


(n, m) = map(int, input().split())
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
res = 1000000000000000000000
for i in range(n):
	maxi = -100000000000000000000
	for j in range(n):
		for k in range(m):
			if j == i:
				continue
			maxi = max(maxi, a[j] * b[k])
	res = min(res, maxi)
print(res)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.sort()
b.sort()
x = max(a[0] * b[m - 1], a[0] * b[0], a[n - 2] * b[m - 1], a[n - 2] * b[0])
y = max(a[1] * b[m - 1], a[1] * b[0], a[n - 1] * b[m - 1], a[n - 1] * b[0])
print(min(x, y))


def find_max(arr1, arr2, index):
	return sorted([arr1[i] * j for i in range(len(arr1)) for j in arr2 if i != index])[-1]
(n, m) = map(int, input().split())
N = sorted(list(map(int, input().split())))
M = sorted(list(map(int, input().split())))
print(min([find_max(N, M, i) for i in range(n)]))


(n, m) = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
max1 = -10 ** 18
max2 = -10 ** 18
pos = -1
for i in range(n):
	for j in range(m):
		l = a[i] * b[j]
		if l > max1:
			max1 = l
			pos = i
a.pop(pos)
for i in range(n - 1):
	for j in range(m):
		l = a[i] * b[j]
		if l > max2:
			max2 = l
print(max2)


(n, m) = list(map(int, input().split()))
a = [int(x) for x in input().split()]
b = sorted([int(x) for x in input().split()])
lo = b[0]
hi = b[-1]
c = []
for k in range(len(a)):
	best = -1000000000000000001
	for i in range(len(a)):
		if i != k:
			best = max([best, a[i] * lo, a[i] * hi])
	c.append(best)
print(min(c))


import math
(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = []
for i in a:
	d = -math.inf
	for j in b:
		d = max(i * j, d)
	c.append(d)
c.sort(reverse=True)
print(c[1])


import math
(n, m) = input().split()
n = int(n)
m = int(m)
a = []
b = []
temp = []
a = list(map(int, input().split()))
b = list(map(int, input().split()))
mini = math.inf
for i in range(n):
	maxi = -math.inf
	for j in range(n):
		if j != i:
			for k in range(m):
				maxi = max(maxi, a[j] * b[k])
	mini = min(mini, maxi)
print(mini)


(n, m) = map(int, input().strip().split())
a = list(map(int, input().strip().split()))
b = list(map(int, input().strip().split()))
t = int(1e+18) + 1
for i in range(n):
	s = int(-1e+18) - 1
	for j in range(n):
		if i == j:
			continue
		for k in range(m):
			s = max(s, a[j] * b[k])
	t = min(t, s)
print(t)


(n, m) = map(int, input().split())
(m1, m2) = (-1e+18, -1e+18)
x = [int(i) for i in input().split()]
y = [int(i) for i in input().split()]
for i in range(n):
	p = -1e+18
	for j in range(m):
		q = x[i] * y[j]
		if q > p:
			p = q
	if p > m1:
		if m1 > m2:
			m2 = m1
		m1 = p
	elif p > m2:
		if m2 > m1:
			m1 = m2
		m2 = p
print(int(min(m1, m2)))


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
l = []
for i in a:
	m = -10000000000000000000
	for j in b:
		m = max(m, i * j)
	l.append(m)
	if len(l) == 3:
		l.sort()
		l.pop(0)
l.sort()
print(l[-2])


(n, m) = input().split()
n = int(n)
m = int(m)
an = list(map(int, input().split()))
bm = list(map(int, input().split()))
mi = 1e+99
pair = -1e+99
for i in range(n):
	pair = -1e+99
	for j in range(m):
		for k in range(n):
			if i != k:
				pair = max(pair, an[k] * bm[j])
	mi = min(mi, pair)
print(mi)


(a, b) = map(int, input().split())
num1 = list(map(int, input().split()))
num2 = list(map(int, input().split()))
ans = []
for i in num1:
	ans.append(max((i * j for j in num2)))
ans.sort()
print(ans[-2])


(n, m) = list(map(int, input().split()))
l1 = list(map(int, input().split()))
l2 = list(map(int, input().split()))
ind = []
ma = -1e+99
for i in range(n):
	for j in range(m):
		if l1[i] * l2[j] > ma:
			ma = l1[i] * l2[j]
			ind = [i]
		elif l1[i] * l2[j] == ma and i not in ind:
			ind.append(i)
if len(ind) > 1:
	print(ma)
else:
	print(max([x * y for x in l1 if x != l1[ind[0]] for y in l2]))


input()
a = list(map(int, input().split()))
b = list(map(int, input().split()))
candi = []
for x in a:
	mx = x * b[0]
	for y in b:
		mx = max(mx, x * y)
	candi.append(mx)
candi.sort()
print(candi[-2])


import sys
(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
v = []
for i in range(n):
	ans = -999999999999999999999999
	for j in range(m):
		ans = max(ans, a[i] * b[j])
	v.append(ans)
v = sorted(v)
print(v[n - 2])


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
m = -100000000000000000000
for i in b:
	for j in a:
		if j * i > m:
			m = j * i
			k = j
a.remove(k)
m = -100000000000000000000
for i in b:
	for j in a:
		if j * i > m:
			m = j * i
print(m)


from math import sqrt

def ii():
	return int(input())

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

def li():
	return list(mi())

def si():
	return input()
(n, m) = mi()
a = li()
b = li()
ans = []
for i in range(n):
	x = []
	for j in range(m):
		x.append(a[i] * b[j])
	ans.append(max(x))
ans.sort(reverse=True)
print(ans[1])


(n, m) = map(int, input().split())
a = map(int, input().split())
b = map(int, input().split())
a = sorted(a, reverse=True)
b = sorted(b, reverse=True)
res = max(a[0] * b[0], a[-1] * b[-1], a[0] * b[-1], a[-1] * b[0])
if res == a[0] * b[0] or res == a[0] * b[-1]:
	a.remove(a[0])
else:
	a.remove(a[-1])
res = max(a[0] * b[0], a[-1] * b[-1], a[0] * b[-1], a[-1] * b[0])
print(res)


(n, m) = (int(i) for i in input().split())
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
res = pow(2, 60)
for i in range(n):
	mx = -pow(2, 60)
	for j in range(n):
		if j != i:
			for k in range(m):
				mx = max(mx, b[k] * a[j])
	res = min(res, mx)
print(res)


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

def brightness(a, b):
	_max = a[0] * b[0]
	for x in a:
		for y in b:
			_max = max(_max, x * y)
	return _max
(n, m) = map(int, input().split())
a = getList()
b = getList()
lenA = len(a)
_min = brightness(a[1:], b)
for i in range(lenA):
	l = a[:i] + a[i + 1:]
	if i == 0:
		_min = brightness(l, b)
	else:
		_min = min(_min, brightness(l, b))
print(_min)


(a, b) = map(int, input().split())
lst1 = list(map(int, input().split()))
lst2 = list(map(int, input().split()))
lst1.sort()
lst2.sort()
lst = lst1[:]
lst1 = lst1[:-1]
n = max(lst1[-1] * lst2[-1], lst1[0] * lst2[0], lst1[0] * lst2[-1], lst1[-1] * lst2[0])
lst1 = lst
lst1 = lst1[1:]
m = max(lst1[-1] * lst2[-1], lst1[0] * lst2[0], lst1[0] * lst2[-1], lst1[-1] * lst2[0])
print(min(n, m))


import os
import sys
from io import BytesIO, IOBase

def main():
	(n, m) = map(int, input().split(' '))
	a = list(map(int, input().split(' ')))
	b = list(map(int, input().split(' ')))
	temp = []
	mxhidden = -1e+100
	hid = 0
	for y in range(m):
		for z in range(n):
			if b[y] * a[z] > mxhidden:
				mxhidden = b[y] * a[z]
				hid = z
	a.pop(hid)
	ans = -1e+100
	for x in range(n - 1):
		for y in range(m):
			ans = max(ans, a[x] * b[y])
	print(ans)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


R = lambda : map(int, input().split())
R()
na = list(R())
nb = list(R())
bcm = None
for i in na:
	cm = float('-inf')
	for j in nb:
		cm = max(cm, i * j)
	if bcm is None or cm > bcm[0]:
		bcm = (cm, i)
na.remove(bcm[1])
m = float('-inf')
for i in na:
	for j in nb:
		m = max(m, i * j)
print(m)


(n, m) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
a.sort()
ans = -999999999999999999999999999
while len(a) > 1 and len(b) > 1:
	max = -999999999999999999999999999
	maxa = 0
	maxb = 0
	for i in a:
		for j in b:
			if i * j >= max:
				max = i * j
				maxa = i
	a.remove(maxa)
	if len(a) == 0:
		break
	max = -999999999999999999999999999
	maxa = 0
	maxb = 0
	for i in a:
		for j in b:
			if i * j >= max:
				max = i * j
				maxa = i
				maxb = j
	a.remove(maxa)
	b.remove(maxb)
	if max >= ans:
		ans = max
print(ans)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = []
for x in a:
	mmax = -10 ** 30
	for y in b:
		z = x * y
		if mmax < z:
			mmax = z
	c.append(mmax)
print(sorted(c)[-2])


from itertools import product
(n, m) = map(int, input().split())
a = sorted(map(int, input().split()))
b = sorted(map(int, input().split()))
res = float('inf')
for i in range(n):
	res = min(res, max((x * y for (x, y) in product(a[:i] + a[i + 1:], b))))
print(res)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = []
for i in range(n):
	mx = -1e+20
	for j in range(n):
		if j == i:
			continue
		for k in range(m):
			mx = max(mx, a[j] * b[k])
	c.append(mx)
print(sorted(c)[0])


(n, m) = map(int, input().split())
a = sorted(list(map(int, input().split())))
b = sorted(list(map(int, input().split())))
print(sorted([a[i] * b[-(a[i] > 0)] for i in range(n)])[-2])


(a, b) = input().split(' ')
a1 = list(map(int, input().split(' ')))
b1 = list(map(int, input().split(' ')))
c = []
for i in a1:
	for j in b1:
		c.append([i * j, i])
c.sort()
a1.remove(c[-1][1])
c = []
for i in a1:
	for j in b1:
		c.append(i * j)
c.sort()
print(c[-1])


(n, m) = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
s = [[max(a) * max(b), 'mx'], [min(a) * min(b), 'mi'], [max(a) * min(b), 'mx'], [min(a) * max(b), 'mi']]
s.sort(key=lambda x: x[0], reverse=True)
if s[0][1] == 'mi':
	a.remove(min(a))
else:
	a.remove(max(a))
s = [max(a) * max(b), min(a) * min(b), max(a) * min(b), min(a) * max(b)]
print(max(s))


(n, m) = map(int, input().split())
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
index = 0
ans = -1000000000000000000
for i in range(n):
	for j in range(m):
		if a[i] * b[j] > ans:
			ans = a[i] * b[j]
			index = i
c = []
for i in range(n):
	if i == index:
		continue
	c.append(a[i])
ans = -1000000000000000000
for j in range(n - 1):
	for k in range(m):
		if c[j] * b[k] > ans:
			ans = c[j] * b[k]
print(ans)


m = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
r = [[max((ax * bx for bx in b))] for ax in a]
r.sort()
print(int(r[-2][0]))


(n, m) = map(int, input().split())
a = sorted(map(int, input().split()))
b = sorted(map(int, input().split()))
ans = 10 ** 18
for i in range(n):
	cur = -10 ** 18
	for u in range(n):
		if u == i:
			continue
		for v in range(m):
			cur = max(cur, a[u] * b[v])
	ans = min(ans, cur)
print(ans)


(n, m) = map(int, input().split())
arr1 = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
ans = []
for i in arr1:
	ans1 = []
	for j in arr2:
		ans1.append(i * j)
	ans.append(max(ans1))
ans.sort(reverse=True)
print(ans[1])


(n, m) = input().split()
(n, m) = (int(n), int(m))
tom = list((i for i in map(int, input().split())))
bon = list((i for i in map(int, input().split())))
if max(tom) > 0 and min(tom) <= 0:
	if max(bon) > 0 and min(bon) > 0:
		tom.remove(max(tom))
	if max(bon) > 0 and min(bon) <= 0:
		if min(tom) * min(bon) > max(tom) * max(bon):
			tom.remove(min(tom))
		else:
			tom.remove(max(tom))
	if max(bon) <= 0 and min(bon) <= 0:
		tom.remove(min(tom))
if max(tom) > 0 and min(tom) > 0:
	if max(bon) > 0 and min(bon) > 0:
		tom.remove(max(tom))
	if max(bon) > 0 and min(bon) <= 0:
		tom.remove(max(tom))
	if max(bon) <= 0 and min(bon) <= 0:
		tom.remove(min(tom))
if max(tom) <= 0 and min(tom) <= 0:
	if max(bon) > 0 and min(bon) > 0:
		tom.remove(max(tom))
	if max(bon) > 0 and min(bon) <= 0:
		tom.remove(min(tom))
	if max(bon) <= 0 and min(bon) <= 0:
		tom.remove(max(tom))
mt = max(tom)
mnt = min(tom)
mb = max(bon)
mnb = min(bon)
r1 = mt * mb
r2 = mnt * mnb
r3 = mt * mnb
r4 = mnt * mb
res = max(r1, r2, r3, r4)
print(res)


import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
(N, M) = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
A.sort()
B.sort()
ans = 1e+20
for i in range(N):
	A2 = A[:i] + A[i + 1:]
	local_ans = -1e+20
	for a in A2:
		for b in B:
			local_ans = max(local_ans, a * b)
	ans = min(ans, local_ans)
print(ans)


(n, m) = [int(x) for x in input().split()]
lstT = [int(x) for x in input().split()]
lstB = [int(x) for x in input().split()]
z = -9999999999999999999999999999
T = 0
B = 0
for i in range(n):
	for j in range(m):
		if z < lstT[i] * lstB[j]:
			T = i
			B = j
			z = lstT[i] * lstB[j]
lol = -99999999999999999999
for i in range(n):
	for j in range(m):
		if T != i:
			lol = max(lol, lstT[i] * lstB[j])
print(lol)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ma = -10 ** 20
for j in range(n):
	for k in range(m):
		p = a[j] * b[k]
		if p > ma:
			ma = p
			x = j
del a[x]
ma = -10 ** 20
for j in range(n - 1):
	for k in range(m):
		ma = max(ma, a[j] * b[k])
print(ma)


(n, m) = map(int, input().split())
l1 = list(map(int, input().split()))
l2 = list(map(int, input().split()))
mx = -100000000000000000000000000000000000
midx = -1
for i in range(n):
	for j in range(m):
		if l1[i] * l2[j] > mx:
			mx = l1[i] * l2[j]
			midx = i
del l1[midx]
mx = -100000000000000000000000000000000000
for i in range(n - 1):
	for j in range(m):
		if l1[i] * l2[j] > mx:
			mx = l1[i] * l2[j]
print(mx)


(n, m) = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
aa = min(a) * min(b)
bb = max(a) * max(b)
cc = min(a) * max(b)
dd = max(a) * min(b)
co = max(aa, bb, cc, dd)
if aa == co or cc == co:
	a.remove(min(a))
else:
	a.remove(max(a))
aa = min(a) * min(b)
bb = max(a) * max(b)
cc = min(a) * max(b)
dd = max(a) * min(b)
print(max(aa, bb, cc, dd))


l = input().split(' ')
(m, n) = [int(i) for i in l]
l1 = [int(i) for i in input().split()]
l2 = [int(i) for i in input().split()]

def search(l1, l2):
	m = l1[0] * l2[0]
	ci = 0
	cj = 0
	for i in range(len(l1)):
		for j in range(len(l2)):
			if l1[i] * l2[j] > m:
				m = l1[i] * l2[j]
				ci = i
				cj = j
	return (m, l1[ci], l2[cj])
(a, b, c) = search(l1, l2)
l1.remove(b)
print(search(l1, l2)[0])


o = lambda : map(int, input().split())
(n, m) = o()
a = sorted(o())
b = sorted(o())
m = -10 ** 25
ans = []
for x in a:
	for y in b:
		ans.append([x * y, x])
ans.sort()
a.remove(ans[-1][1])
ans = []
for x in a:
	for y in b:
		ans.append(x * y)
ans.sort()
print(ans[-1])


def main():
	(N, M) = map(int, input().split())
	A = tuple(map(int, input().split()))
	B = tuple(map(int, input().split()))
	ans = []
	apnd = ans.append
	for i in sorted(A):
		n = -float('inf')
		for j in B:
			n = max(n, i * j)
		apnd(n)
	print(min(max(ans[1:]), max(ans[:-1])))
main()


(n, m) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
big = 10 ** 25
small = -10 ** 25
ans = big
for i in range(len(a)):
	tmp = small
	for j in range(len(a)):
		if i == j:
			continue
		for x in b:
			_ = a[j] * x
			if _ > tmp:
				tmp = _
	if tmp < ans:
		ans = tmp
print(ans)


(n, m) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
mn = 10 ** 20
for i in range(n):
	mx = -1 * 10 ** 20
	for j in range(n):
		if j == i:
			continue
		for k in range(m):
			mx = max(mx, a[j] * b[k])
	mn = min(mn, mx)
print(mn)


(n, m) = list(map(int, input().split()))
nl = []
ml = []
nl = list(map(int, input().split()))
ml = list(map(int, input().split()))
nl.sort()
ml.sort()
a = nl[0] * ml[-1]
b = nl[-1] * ml[0]
c = nl[-1] * ml[-1]
d = nl[0] * ml[0]
curr = [a, b, c, d]
if max(curr) == a or max(curr) == d:
	nl.pop(0)
else:
	nl.pop(-1)
a = nl[0] * ml[-1]
b = nl[-1] * ml[0]
c = nl[-1] * ml[-1]
d = nl[0] * ml[0]
curr = [a, b, c, d]
print(max(curr))


(n, m) = map(int, input().split())
b = sorted(map(int, input().split()))
c = sorted(map(int, input().split()))
a = b[0] * c[0]
i_k = 0
for i in range(len(b)):
	for j in range(len(c)):
		if b[i] * c[j] > a:
			a = b[i] * c[j]
			i_k = i
del b[i_k]
a = b[0] * c[0]
for i in range(len(b)):
	for j in range(len(c)):
		if b[i] * c[j] > a:
			a = b[i] * c[j]
print(a)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.sort()
b.sort()
max_banban = a[0] * b[0]
Tommy_to_delete = 0
for (i, fst) in enumerate(a):
	for snd in b:
		if fst * snd > max_banban:
			max_banban = fst * snd
			Tommy_to_delete = i
ans = None
for (i, fst) in enumerate(a):
	if i != Tommy_to_delete:
		for snd in b:
			if ans == None or fst * snd > ans:
				ans = fst * snd
print(ans)


from sys import stdin, stdout
(n, m) = map(int, stdin.readline().split())
first = list(map(int, stdin.readline().split()))
second = list(map(int, stdin.readline().split()))
ans = float('inf')
for i in range(n):
	cnt = float('-inf')
	for j in range(m):
		for z in range(n):
			if z == i:
				continue
			cnt = max(cnt, first[z] * second[j])
	ans = min(ans, cnt)
stdout.write(str(ans))


import sys, math
(n, m) = map(int, sys.stdin.readline().split())
a = list(map(int, sys.stdin.readline().split()))
b = list(map(int, sys.stdin.readline().split()))
ans = 10 ** 20
for i in range(n):
	temp = -10 ** 20
	for j in range(n):
		if i != j:
			for k in range(m):
				temp = max(temp, a[j] * b[k])
	ans = min(ans, temp)
print(ans)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
save = []
for i in a:
	mx = -10 ** 19
	for j in b:
		mx = max(mx, i * j)
	save.append(mx)
save = sorted(save)
print(save[-2])


(tommy, banban) = list(map(int, input().split(' ')))
allTommy = sorted(list(map(int, input().split(' '))))
allBanban = sorted(list(map(int, input().split(' '))))
allValues = []
for i in allTommy:
	for j in allBanban:
		allValues.append([i * j, i, j])
allValues.sort()
i = 0
while i < len(allTommy):
	if allTommy[i] == allValues[-1][1]:
		allTommy.pop(i)
		break
	i += 1
newValues = []
for i in allTommy:
	for j in allBanban:
		newValues.append(i * j)
newValues.sort()
print(newValues[-1])


(n, m) = map(int, input().split())
t = list(map(int, input().split()))
b = list(map(int, input().split()))
t = sorted(t, reverse=True)
b = sorted(b, reverse=True)
temp = 0
ans = int(-1e+20)
for i in t:
	for j in b:
		if i * j > ans:
			ans = i * j
			temp = i
t.remove(temp)
print(sorted([i * j for i in t for j in b])[-1])


input()
a = list(map(int, input().split()))
b = list(map(int, input().split()))
k = [max(a), min(a)]
a.remove(max(a))
a.remove(min(a))
c = []
d = []
for i in a:
	for j in b:
		c.append(i * j)
		d.append(i * j)
for i in b:
	c.append(k[0] * i)
for i in b:
	d.append(k[1] * i)
print(min(max(c), max(d)))


(n, m) = map(int, input().split())
tom = list(map(int, input().split()))
ban = list(map(int, input().split()))
a1 = max(tom)
a2 = min(tom)
b1 = max(ban)
b2 = min(ban)
if max(a1 * b1, a1 * b2) <= max(a2 * b1, a2 * b2):
	tom.remove(a2)
else:
	tom.remove(a1)
r = -4557430888798830399
for i in tom:
	for j in ban:
		if i * j > r:
			r = i * j
print(r, flush=True)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = 1e+180
for i in range(n):
	val = -1e+180
	for j in range(n):
		if j == i:
			continue
		for t in range(m):
			val = max(val, a[j] * b[t])
	ans = min(ans, val)
print(ans)


(n, m) = map(int, input().split())
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
c = [[0 for i in range(m)] for j in range(n)]
a_max = [0 for i in range(n)]
mu_max_id = 0
a_max[0] = c[0][0] = a[0] * b[0]
for j in range(1, m):
	c[0][j] = a[0] * b[j]
	if c[0][j] > a_max[0]:
		a_max[0] = c[0][j]
for i in range(1, n):
	a_max[i] = c[i][0] = a[i] * b[0]
	for j in range(1, m):
		c[i][j] = a[i] * b[j]
		if c[i][j] > a_max[i]:
			a_max[i] = c[i][j]
	if a_max[i] > a_max[mu_max_id]:
		mu_max_id = i
a.pop(mu_max_id)
ans = a[0] * b[0]
for i in range(n - 1):
	for j in range(m):
		ans = max(ans, a[i] * b[j])
print(ans)


input()
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.sort()
b.sort()
ans1 = max(a[-2] * b[-1], a[0] * b[0], a[0] * b[-1], a[-2] * b[0])
ans2 = max(a[-1] * b[-1], a[1] * b[0], a[-1] * b[0], a[1] * b[-1])
print(min(ans1, ans2))


(n, m) = map(int, input().strip().split(' '))
a = list(map(int, input().strip().split(' ')))
b = list(map(int, input().strip().split(' ')))
re = sorted([(max(a) * max(b), max(a)), (min(a) * max(b), min(a)), (max(a) * min(b), max(a)), (min(a) * min(b), min(a))])[-1][1]
a.remove(re)
re = sorted([(max(a) * max(b), max(a)), (min(a) * max(b), min(a)), (max(a) * min(b), max(a)), (min(a) * min(b), min(a))])[-1][0]
print(re)


(m, n) = map(int, input().split())
lst1 = list(map(int, input().split()))
lst2 = list(map(int, input().split()))
lst0 = []
for i in lst1:
	lst0.append(max([i * j for j in lst2]))
ans = sorted(lst0)[-2]
print(ans)


def main():
	(n, m) = map(int, input().split())
	a = map(int, input().split())
	b = list(map(int, input().split()))
	l = []
	for (i, x) in enumerate(a):
		for y in b:
			l.append((x * y, i))
	l.sort(key=lambda x: x[0])
	for x in reversed(l):
		if x[1] != l[-1][1]:
			print(x[0])
			break
main()


(n, m) = [int(x) for x in input().split(' ')]
na = [int(x) for x in input().split(' ')]
nb = [int(x) for x in input().split(' ')]
na.sort()
nb.sort()
ans = -1000000000000000001
store = 0
for i in na:
	for j in nb:
		if i * j > ans:
			ans = max(i * j, ans)
			store = i
na.remove(store)
ans = -1000000000000000001
for i in na:
	for j in nb:
		ans = max(i * j, ans)
print(ans)


def compatible_pair(l1, l2):
	l1 = sorted(l1)
	l2 = sorted(l2)
	return min((max((x * y for x in [l2[0], l2[-1]] for y in l)) for l in [[l1[0], l1[-2]], [l1[1], l1[-1]]]))
input()
l1 = list(map(int, input().split()))
l2 = list(map(int, input().split()))
print(compatible_pair(l1, l2))


(n, m) = map(int, input().split())
arr1 = sorted(map(int, input().split()))
arr2 = sorted(map(int, input().split()))
if arr1[-1] * arr2[-1] > arr1[0] * arr2[0]:
	l = max(arr1[-2] * arr2[-1], arr1[0] * arr2[0])
	if n > 2:
		l = max(l, arr1[1] * arr2[-1])
	if m > 2:
		l = max(l, arr1[-2] * arr2[0])
else:
	l = max(arr1[-1] * arr2[-1], arr1[1] * arr2[0])
	if n > 2:
		l = max(l, arr1[1] * arr2[-1])
	if m > 2:
		l = max(l, arr1[-2] * arr2[0])
print(l)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
res = [[max((a1 * b1 for b1 in b))] for a1 in a]
res.sort()
print(res[-2][0])


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = 10 ** 18
for i in range(n):
	M = -10 ** 18
	for j in range(n):
		if j == i:
			continue
		for k in range(m):
			M = max(M, a[j] * b[k])
	ans = min(ans, M)
print(ans)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.sort()
b.sort()
amin1 = a[0]
amin2 = a[1]
amax1 = a[-1]
amax2 = a[-2]
bmin1 = b[0]
bmin2 = b[1]
bmax1 = b[-1]
bmax2 = b[-2]
a1 = max(amin1 * bmin1, amin1 * bmax1)
a2 = max(amax1 * bmin1, amax1 * bmax1)
x11 = amin2 * bmin1
x12 = amin2 * bmax1
x13 = amax1 * bmax1
x14 = amax1 * bmin1
x1 = max(x11, x12, x13, x14)
x21 = amax2 * bmax1
x22 = amax2 * bmin1
x23 = amin1 * bmin1
x24 = amin1 * bmax1
x2 = max(x21, x22, x23, x24)
if a1 < a2:
	print(x2)
else:
	print(x1)


(n, m) = [int(x) for x in input().split(' ')]
a = [int(x) for x in input().split(' ')]
b = [int(x) for x in input().split(' ')]
r = []
for x in a:
	r.append(max([x * y for y in b]))
r.sort()
print(r[-2])


(n, m) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
b.sort()
first = []
for x in a:
	if x > 0:
		first.append(x * b[-1])
	elif x < 0:
		first.append(x * b[0])
	else:
		first.append(0)
ans = 10 ** 25
for i in range(len(a)):
	s = -10 ** 25
	for j in range(len(a)):
		if j != i:
			if first[j] > s:
				s = first[j]
	if s < ans:
		ans = s
print(ans)


n = 0
m = 0
MaxP = 0
A = [0] * 100
B = [0] * 100
MaxV = -99999999999999999999999999999999999999
(n, m) = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
for i in range(n):
	for j in range(m):
		if MaxV < A[i] * B[j]:
			MaxP = i
			MaxV = A[i] * B[j]
MaxV = -99999999999999999999999999999999999999999
for i in range(n):
	if i != MaxP:
		for j in range(m):
			if MaxV < A[i] * B[j]:
				MaxV = A[i] * B[j]
print(MaxV)


[n, m] = input().split(' ')
n = int(n)
m = int(m)
lin1 = input().split(' ')
lin2 = input().split(' ')
a = []
b = []
for i in range(n):
	a.append(int(lin1[i]))
for i in range(m):
	b.append(int(lin2[i]))
maxn = -9e+18
for i in range(n):
	for j in range(m):
		if a[i] * b[j] > maxn:
			maxn = a[i] * b[j]
			p1 = i
			p2 = j
maxn = -9e+18
for i in range(n):
	for j in range(m):
		if i == p1:
			continue
		if a[i] * b[j] > maxn:
			maxn = a[i] * b[j]
print(maxn)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
inf = 10 ** 18
ans = inf
for hide in range(n):
	get = -inf
	for i in range(n):
		for j in range(m):
			if i != hide:
				get = max(get, a[i] * b[j])
	ans = min(ans, get)
print(ans)


R = lambda : map(int, input().split())
(n, m) = R()
a = list(R())
b = list(R())
a.sort(reverse=True)
b.sort(reverse=True)
a1 = a[0] * b[0]
a2 = a[0] * b[m - 1]
a3 = a[n - 1] * b[0]
a4 = a[n - 1] * b[m - 1]
if max(a1, a2, a3, a4) == max(a1, a2):
	a = a[1:]
else:
	a = a[:n - 1]
a1 = a[0] * b[0]
a2 = a[0] * b[m - 1]
a3 = a[n - 2] * b[0]
a4 = a[n - 2] * b[m - 1]
print(max(a1, a2, a3, a4))


(n, m) = map(int, input().split())
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
res = 1000000000000000000000000000
for i in range(n):
	maxi = -100000000000000000000000
	for j in range(n):
		for k in range(m):
			if j != i:
				maxi = max(maxi, a[j] * b[k])
	res = min(res, maxi)
print(res)


(n, m) = map(int, input().split())
l = sorted(list(map(int, input().split())))
l1 = sorted(list(map(int, input().split())))
ma = l[0] * l1[0]
ma1 = l[1] * l1[0]
for i in range(n - 1):
	for j in range(m):
		ma = max(ma, l[i] * l1[j])
for i in range(1, n):
	for j in range(m):
		ma1 = max(ma1, l[i] * l1[j])
print(min(ma1, ma))


import os
import sys
from io import BytesIO, IOBase

def main():
	(n, m) = map(int, input().split())
	a = list(map(int, input().split()))
	b = list(map(int, input().split()))
	ans = float('inf')
	for i in range(n):
		curr = -float('inf')
		for j in range(n):
			if i != j:
				for k in range(m):
					curr = max(curr, a[j] * b[k])
		ans = min(ans, curr)
	print(ans)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


(n, m) = [int(k) for k in input().split(' ') if k]
tom = [int(k) for k in input().split(' ') if k]
ban = [int(k) for k in input().split(' ') if k]
maxMultipleAverall = -1000000000 * 10000000000
exclude = n + 1
for i in range(n):
	maxMultiple = -1000000000 * 10000000000
	for j in range(m):
		if tom[i] * ban[j] > maxMultiple:
			secondMaxMultiple = int(maxMultiple)
			maxMultiple = tom[i] * ban[j]
	if maxMultiple > maxMultipleAverall:
		maxMultipleAverall = maxMultiple
		exclude = i
assert 0 <= exclude < n
del tom[exclude]
maxMultipleAverall = -1000000000 * 10000000000
for i in range(n - 1):
	for j in range(m):
		if tom[i] * ban[j] > maxMultipleAverall:
			maxMultipleAverall = tom[i] * ban[j]
print(maxMultipleAverall)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
p = []
for i in a:
	for j in b:
		p.append([i * j, i, j])
p = sorted(p)
del a[a.index(p[-1][1])]
p = []
for i in a:
	for j in b:
		p.append(i * j)
p = sorted(p)
print(p[-1])


from sys import stdin
(n, m) = map(int, stdin.readline().strip().split())
s = list(map(int, stdin.readline().strip().split()))
s1 = list(map(int, stdin.readline().strip().split()))
ans = 10 ** 20
for i in range(n):
	ans1 = -10 ** 20
	for j in range(m):
		for k in range(n):
			if k == i:
				continue
			ans1 = max(ans1, s[k] * s1[j])
	ans = min(ans1, ans)
print(ans)


(n, m) = map(int, input().split())
tn = list(map(int, input().split()))
tm = list(map(int, input().split()))

def absmax():
	return max([max(tm) * max(tn), max(tm) * min(tn), min(tm) * max(tn), min(tm) * min(tn)])
if absmax() == max(tm) * max(tn):
	tn.remove(max(tn))
elif absmax() == max(tm) * min(tn):
	tn.remove(min(tn))
elif absmax() == min(tm) * max(tn):
	tn.remove(max(tn))
else:
	tn.remove(min(tn))
print(absmax())


(n, m) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
res = 10000000000000000007
for i in range(n):
	ans = -10000000000000000007
	for j in range(n):
		if j != i:
			for k in range(m):
				ans = max(ans, a[j] * b[k])
	res = min(res, ans)
print(res)


(n, m) = map(int, input().split())
lst1 = []
for x in input().split():
	lst1.append(int(x))
lst2 = []
for x in input().split():
	lst2.append(int(x))
lst = []
for x in lst1:
	maxi = -10 ** 18
	for y in lst2:
		maxi = max(maxi, x * y)
	lst.append(maxi)
lst.sort()
print(lst[-2])


(tommy, banban) = input().split()
a = []
b = []
a = input().split(' ')
b = input().split(' ')
max = 0
maxac = 0
for x in range(0, int(tommy)):
	a[x] = int(a[x])
for x in range(0, int(banban)):
	b[x] = int(b[x])
for x in range(0, int(tommy)):
	for y in range(0, int(banban)):
		if x == 0 and y == 0:
			max = a[x] * b[y]
			maxac = a[x]
		if a[x] * b[y] > max:
			max = a[x] * b[y]
			maxac = a[x]
a.remove(maxac)
max = 0
for x in range(0, int(tommy) - 1):
	for y in range(0, int(banban)):
		if x == 0 and y == 0:
			max = a[x] * b[y]
		if a[x] * b[y] > max:
			max = a[x] * b[y]
print(max)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c1 = float('inf')
for i in range(n):
	c2 = float('-inf')
	for j in range(n):
		if i != j:
			for k in range(m):
				c2 = max(c2, a[j] * b[k])
	c1 = min(c1, c2)
print(c1)


(n, m) = input().split(' ')
n = int(n)
m = int(m)
masA = input().split(' ')
masB = input().split(' ')
for a in range(0, n):
	masA[a] = int(masA[a])
for b in range(0, m):
	masB[b] = int(masB[b])
max = masA[0] * masB[0]
a = 0
for i in range(0, n):
	for j in range(0, m):
		if max <= masA[i] * masB[j]:
			max = masA[i] * masB[j]
			a = i
del masA[a]
twoMax = masA[0] * masB[0]
for i in range(0, n - 1):
	for j in range(0, m):
		if twoMax <= masA[i] * masB[j]:
			twoMax = masA[i] * masB[j]
print(twoMax)


(m, n) = [int(x) for x in input().split()]
lstM = sorted([int(x) for x in input().split()])
lstN = sorted([int(x) for x in input().split()])
if max([lstM[0] * lstN[h] for h in range(len(lstN))]) > max([lstM[-1] * lstN[h] for h in range(len(lstN))]):
	del lstM[0]
else:
	del lstM[-1]
max_bt = max(max([lstM[0] * lstN[h] for h in range(len(lstN))]), max([lstM[-1] * lstN[h] for h in range(len(lstN))]))
print(max_bt)


(n, m) = map(int, input().split())
an = list(map(int, input().split()))
am = list(map(int, input().split()))
l = []
for i in an:
	mx = i * am[0]
	for j in am:
		mx = max(mx, i * j)
	l.append(mx)
l.sort()
print(l[-2])


(b, m) = map(int, input().split())
boy = map(int, input().split())
man = sorted(map(int, input().split()))
optimal = sorted((max(b * man[0], b * man[-1]) for b in boy))
optimal.remove(max(optimal))
print(max(optimal))


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
mx1 = float('-inf')
mx2 = 0
for i in range(n):
	for j in range(m):
		if a[i] * b[j] > mx1:
			mx2 = i
			mx1 = a[i] * b[j]
mx1 = float('-inf')
for i in range(n):
	if i == mx2:
		continue
	for j in range(m):
		mx1 = max(mx1, a[i] * b[j])
print(mx1)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.sort()
b.sort()
m1 = max(a[1] * b[0], a[n - 1] * b[m - 1], b[m - 1] * a[1], a[n - 1] * b[0])
m2 = max(a[0] * b[0], a[n - 2] * b[m - 1], b[m - 1] * a[0], a[n - 2] * b[0])
m2 = min(m1, m2)
print(m2)


(n, m) = list(map(int, input().split()))
l = list(map(int, input().split()))
x = list(map(int, input().split()))
d = {}
for i in l:
	for j in x:
		d[i, j] = i * j
c = -9999999999999999999
for i in d:
	if d[i] > c:
		c = d[i]
		y = i[0]
l.remove(y)
c = -9999999999999999999
for i in l:
	for j in x:
		c = max(c, i * j)
print(c)


def CF934A():
	(n, m) = input('').split(' ')
	n = int(n)
	m = int(m)
	x = input('').split(' ')
	y = input('').split(' ')
	mini = 1234567890 ** 2
	for blocked in range(0, len(x)):
		maxi = -1234567890 ** 2
		for i in range(0, len(x)):
			if blocked == i:
				continue
			for v in y:
				maxi = max(maxi, int(x[i]) * int(v))
		mini = min(mini, maxi)
	print(mini)
CF934A()


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
rec = []
for i in range(n):
	tmp = []
	for j in range(m):
		tmp.append(a[i] * b[j])
	rec.append(max(tmp))
rec = sorted(rec)
print(rec[-2])


(nm, n, m) = ([int(i) for i in input().split()], [int(i) for i in input().split()], [int(i) for i in input().split()])
mx = -1000000000000000000000000000000
si = 0
for i in n:
	for j in m:
		if i * j >= mx:
			mx = i * j
			si = i
n.remove(si)
mx = -1000000000000000000000000000000
for i in n:
	for j in m:
		if i * j >= mx:
			mx = i * j
print(mx)


(t, b) = map(int, input().split())
t = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = [-10000000000000000000] * len(t)
for i in range(len(t)):
	ans[i] = t[i] * max(b)
	if t[i] < 0:
		ans[i] = t[i] * min(b)
ans.sort()
print(ans[len(ans) - 2])


def resi_bez(zab, a, b):
	prvi = True
	max = 0
	for vred in b:
		for i in range(len(a)):
			if i != zab and (prvi or vred * a[i] > max):
				prvi = False
				max = vred * a[i]
	return max
(n, m) = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
tr = resi_bez(0, a, b)
for i in range(len(a)):
	tr = min(tr, resi_bez(i, a, b))
print(tr)


(n, m) = map(int, input().split())
l1 = [int(x) for x in input().split()]
l2 = [int(x) for x in input().split()]
r = [[max((a * b for b in l2))] for a in l1]
r.sort()
print(r[-2][0])


s = input().split()
s1 = input().split()
s2 = input().split()
n = int(s[0])
m = int(s[1])
list2 = []
list1 = []
for i in s1:
	list1.append(int(i))
for i in s2:
	list2.append(int(i))
list1.sort()
list2.sort()
cl = []
for i in list1:
	z = []
	for j in list2:
		z.append(i * j)
	cl.append(max(z))
cl.sort()
print(cl[n - 2])


(n, m) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
res = [max([ax * bx for bx in b]) for ax in a]
res.sort(reverse=True)
print(res[1])


import math
(m, n) = input().split()
(m, n) = (int(m), int(n))
A = [int(i) for i in input().split()]
B = [int(i) for i in input().split()]
(Q, W) = (A, B)
A.sort()
B.sort()
maxprod = -math.inf
while len(A) > 0 and len(B) > 0:
	val1 = A[0] * B[0]
	val2 = A[0] * B[-1]
	val3 = A[-1] * B[0]
	val4 = A[-1] * B[-1]
	x = max(val1, val2, val3, val4)
	if val1 == x or val2 == x:
		A.pop(0)
		if len(A) == 0 or len(B) == 0:
			break
		val1 = A[0] * B[0]
		val2 = A[0] * B[-1]
		val3 = A[-1] * B[0]
		val4 = A[-1] * B[-1]
		y = max(val1, val2, val3, val4)
		if val1 == y:
			A.pop(0)
			B.pop(0)
			maxprod = max(val1, maxprod)
		elif val2 == y:
			A.pop(0)
			B.pop(-1)
			maxprod = max(maxprod, val2)
		elif val3 == y:
			A.pop(-1)
			B.pop(0)
			maxprod = max(maxprod, val3)
		else:
			A.pop(-1)
			B.pop(-1)
			maxprod = max(maxprod, val4)
	else:
		A.pop(-1)
		if len(A) == 0 or len(B) == 0:
			break
		val1 = A[0] * B[0]
		val2 = A[0] * B[-1]
		val3 = A[-1] * B[0]
		val4 = A[-1] * B[-1]
		y = max(val1, val2, val3, val4)
		if val1 == y:
			A.pop(0)
			B.pop(0)
			maxprod = max(val1, maxprod)
		elif val2 == y:
			A.pop(0)
			B.pop(-1)
			maxprod = max(maxprod, val2)
		elif val3 == y:
			A.pop(-1)
			B.pop(0)
			maxprod = max(maxprod, val3)
		else:
			A.pop(-1)
			B.pop(-1)
			maxprod = max(maxprod, val4)
if maxprod == -math.inf:
	print(max(max(A) * max(B), min(A) * min(B), max(A) * min(B), min(A) * max(B)))
else:
	print(maxprod)


n = input().split()
a = list(map(int, input().split(' ')))
b = list(map(int, input().split(' ')))
t = []
for i in range(len(a)):
	p = a[0]
	del a[0]
	t.append(max(max(a) * max(b), min(a) * min(b), min(a) * max(b), max(a) * min(b)))
	a.append(p)
print(min(t))