Nick has n bottles of soda left after his birthday. Each bottle is described by two values: remaining amount of soda a_{i} and bottle volume b_{i} (a_{i} ≤ b_{i}).

Nick has decided to pour all remaining soda into minimal number of bottles, moreover he has to do it as soon as possible. Nick spends x seconds to pour x units of soda from one bottle to another.

Nick asks you to help him to determine k — the minimal number of bottles to store all remaining soda and t — the minimal time to pour soda into k bottles. A bottle can't store more soda than its volume. All remaining soda should be saved.


-----Input-----

The first line contains positive integer n (1 ≤ n ≤ 100) — the number of bottles.

The second line contains n positive integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 100), where a_{i} is the amount of soda remaining in the i-th bottle.

The third line contains n positive integers b_1, b_2, ..., b_{n} (1 ≤ b_{i} ≤ 100), where b_{i} is the volume of the i-th bottle.

It is guaranteed that a_{i} ≤ b_{i} for any i.


-----Output-----

The only line should contain two integers k and t, where k is the minimal number of bottles that can store all the soda and t is the minimal time to pour the soda into k bottles.


-----Examples-----
Input
4
3 3 4 3
4 7 6 5

Output
2 6

Input
2
1 1
100 100

Output
1 1

Input
5
10 30 5 6 24
10 41 7 8 24

Output
3 11



-----Note-----

In the first example Nick can pour soda from the first bottle to the second bottle. It will take 3 seconds. After it the second bottle will contain 3 + 3 = 6 units of soda. Then he can pour soda from the fourth bottle to the second bottle and to the third bottle: one unit to the second and two units to the third. It will take 1 + 2 = 3 seconds. So, all the soda will be in two bottles and he will spend 3 + 3 = 6 seconds to do it.

Difficulty: HARD

Solutions:
f = lambda : list(map(int, input().split()))
n = int(input())
(a, b) = (f(), f())
d = [[None] * 10001 for i in range(n)]

def g(i, s):
	if s <= 0:
		return (0, s)
	if i == n:
		return (10000000.0, 0)
	if not d[i][s]:
		(x, y) = g(i + 1, s - b[i])
		d[i][s] = min(g(i + 1, s), (x + 1, y + b[i] - a[i]))
	return d[i][s]
(x, y) = g(0, sum(a))
print(x, y)


import math
from collections import defaultdict
import os
import sys
from io import BytesIO, IOBase
from types import GeneratorType
from collections import defaultdict
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')
sys.setrecursionlimit(10 ** 5)

def calc(i, total):
	if total <= 0:
		return [0, total]
	if i == -1:
		return [float('inf'), float('inf')]
	if dp[i, total][0] != -1:
		return dp[i, total]
	poss1 = calc(i - 1, total)
	poss2 = calc(i - 1, total - b[i])
	poss2[0] += 1
	poss2[1] += b[i] - a[i]
	if poss1[0] < poss2[0]:
		dp[i, total][0] = poss1[0]
		dp[i, total][1] = poss1[1]
	elif poss1[0] > poss2[0]:
		dp[i, total][0] = poss2[0]
		dp[i, total][1] = poss2[1]
	elif poss1[1] < poss2[1]:
		dp[i, total][0] = poss1[0]
		dp[i, total][1] = poss1[1]
	else:
		dp[i, total][0] = poss2[0]
		dp[i, total][1] = poss2[1]
	return [dp[i, total][0], dp[i, total][1]]
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
s = sum(a)
dp = defaultdict(lambda : [-1, 0])
val = calc(n - 1, s)
print(val[0], val[1])