There are $n$ benches in the Berland Central park. It is known that $a_i$ people are currently sitting on the $i$-th bench. Another $m$ people are coming to the park and each of them is going to have a seat on some bench out of $n$ available.

Let $k$ be the maximum number of people sitting on one bench after additional $m$ people came to the park. Calculate the minimum possible $k$ and the maximum possible $k$.

Nobody leaves the taken seat during the whole process.


-----Input-----

The first line contains a single integer $n$ $(1 \le n \le 100)$ — the number of benches in the park.

The second line contains a single integer $m$ $(1 \le m \le 10\,000)$ — the number of people additionally coming to the park.

Each of the next $n$ lines contains a single integer $a_i$ $(1 \le a_i \le 100)$ — the initial number of people on the $i$-th bench.


-----Output-----

Print the minimum possible $k$ and the maximum possible $k$, where $k$ is the maximum number of people sitting on one bench after additional $m$ people came to the park.


-----Examples-----
Input
4
6
1
1
1
1

Output
3 7

Input
1
10
5

Output
15 15

Input
3
6
1
6
5

Output
6 12

Input
3
7
1
6
5

Output
7 13



-----Note-----

In the first example, each of four benches is occupied by a single person. The minimum $k$ is $3$. For example, it is possible to achieve if two newcomers occupy the first bench, one occupies the second bench, one occupies the third bench, and two remaining — the fourth bench. The maximum $k$ is $7$. That requires all six new people to occupy the same bench.

The second example has its minimum $k$ equal to $15$ and maximum $k$ equal to $15$, as there is just a single bench in the park and all $10$ people will occupy it.

Difficulty: interview

Starter code:

Solutions:
n = int(input())
m = int(input())
a = []
for i in range(n):
    a.append(int(input()))

mx = max(a) + m



while m:
    for i in range(n):
        if a[i] == min(a):
            a[i] += 1
            m -= 1
            break

print(max(a), mx)


#      
import collections, atexit, math, sys, bisect 

sys.setrecursionlimit(1000000)
def getIntList():
    return list(map(int, input().split()))    

try :
    #raise ModuleNotFoundError
    import numpy
    def dprint(*args, **kwargs):
        print(*args, **kwargs, file=sys.stderr)
    dprint('debug mode')
except Exception:
    def dprint(*args, **kwargs):
        pass



inId = 0
outId = 0
if inId>0:
    dprint('use input', inId)
    sys.stdin = open('input'+ str(inId) + '.txt', 'r') #标准输出重定向至文件
if outId>0:
    dprint('use output', outId)
    sys.stdout = open('stdout'+ str(outId) + '.txt', 'w') #标准输出重定向至文件
    atexit.register(lambda :sys.stdout.close())     #idle 中不会执行 atexit
    

N = int(input())

M = int(input())
za = []
for i in range(N):
    za.append( int(input()) )
    
t = sum(za)

x = (t+ M - 1) //N + 1
print( max(x, max(za)), max(za) + M)








from math import ceil

n = int(input())
m = int(input())

bs = []
for _ in range(n):
    bs.append(int(input()))

b = max(bs)
total = sum(bs) + m

maximum = b + m
if total <= b * n:
    minimum = b
else:
    minimum = int(ceil(total / n))

print(minimum, maximum)


n = int(input())
m = int(input())
a = []
for i in range(n):
    a.append(int(input()))

mxa = max(a)
rmx = mxa + m
for x in a:
    m -= mxa - x

rmn = mxa
if m > 0:
    rmn += (m + n - 1) // n

print(rmn, rmx)

n = int(input())
m = int(input())

aa = []
for i in range(n):
    aa += [int(input())]

maxAns = max(aa) + m

rest = max(aa) * n - sum(aa)
if m <= rest:
    minAns = max(aa)
else:
    m -= rest
    minAns = max(aa) + (m + n - 1) // n

print(minAns, maxAns)

import math
n = int(input())
m = int(input())
a = []
for i in range(n):
    a.append(int(input()))
maxs = max(a)
m1 = m
for i in a:
    m -= (maxs - i)

print(maxs + max(math.ceil(m / n), 0), maxs + m1)



n = int(input())
m = int(input())
u = []
for i in range(n):
    u.append(int(input()))
k = max(u)
a1 = k + m
for i in range(n):
    m -= k - u[i]
if m > 0:
    k += m // n
    if m % n != 0:
        k += 1
print(k, a1)


n=int(input())
m=int(input())
a=[int(input()) for i in range(n)]
max_k= max(a)+m
max_a=max(a)
for ax in a:
    m-=max_a-ax
min_k = max(a)
if m>0:
    min_k += m//n
    if m%n>0:
        min_k+=1
print(min_k, max_k)





n, m = int(input()), int(input())
a = []
for i in range(n):
    a.append(int(input()))
ma = max(a) + m
m -= max(a) * n - sum(a)
mi = max(a) + max(0, (m + n - 1) // n)
print(mi, ma)


n = int(input())
m = int(input())
a = sorted([int(input()) for i in range(n)])
ans2 = max(a) + m
for i in range(n):
  m -= a[-1] - a[i]
  a[i] += a[-1] - a[i]
ans1 = a[-1] if m <= 0 else a[-1] + (m + n - 1) // n
print(ans1, ans2)


n = int(input())
m = int(input())
a = [int(input()) for _ in range(n)]

ans = [max(a), max(a) + m]
d = m - n * max(a) + sum(a)
if 0 < d:
    ans[0] += (d + n - 1) // n

print(" ".join(map(str, ans)))


n=int(input())
m=int(input())
l=[0 for i in range(n)]
for i in range(n):
	l[i]=int(input())
d1=max(l)
d2=min(l)
e=sum(l)
r=(e+m)
if (r%n==0):
	r1=r//n
else:
	r1=r//n+1
print (max(d1,r1),d1+m)

n = int(input())
m = int(input())
l = []
for i in range(n):
	l.append(int(input()))
ma = max(l)
mx = ma+m
l.sort()
for i in range(n):
	m-=(ma-l[i])
if(m<=0):
	mi = ma
else:
	mi = ma+m//n
	if(m%n!=0):
		mi+=1
print(mi,mx)

n = int(input())
m = int(input())
a = []
for _ in range(n):
    a.append(int(input()))
a = sorted(a)
max_i = max(a) + m
for i in range(m):
    a[0] += 1
    a = sorted(a)
min_i = max(a)
print(min_i, max_i)

# ns=[int(x)for x in input().split()]
n=int(input())
m=int(input())
ns=[]
for _ in range(n):
    ns.append(int(input()))
maxx=max(ns)
ans2=maxx+m

hole=0
for t in ns:
    hole+=maxx-t

if hole>=m:
    ans1=maxx
else:
    m-=hole
    ans1=maxx+(m//n)
    if m%n!=0:
        ans1+=1
print(ans1,ans2)

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import time
import math

n       = int(input())
m       = int(input())
a       = []

for i in range(n):
    a.append(int(input()))

start   = time.time()

max_now = max(a)
sum     = 0

for i in range(n):
    sum += max_now-a[i]

ans_max = max_now+m
if sum >= m:
    ans_min = max_now
else:
    ans_min=max_now+math.ceil((m-sum)/n)

print(ans_min, ans_max)
finish = time.time()
#print(finish - start)


import math
n = int(input())
m = int(input())
x = m

arr = []
for i in range(n):
    arr.append(int(input()))

maxx = max(arr)

summ = 0

for i in range(n):
    if arr[i] <= maxx:
        if m >= maxx - arr[i]:
            m -= maxx - arr[i]
            arr[i] = maxx
        else:
            arr[i] += m
            m = 0

print(maxx + math.ceil(m/n), maxx + x)



import math
n=int(input())
m=int(input())
a=[]
for i in range(n):
    a.append(int(input()))

x=max(a)
y=min(a)
op=((sum(a)+m)/n)
# print(op)
if(op!=int(op)):
    op=op+1
print(max(x,int(op)),x+m)


n = int(input())
m = int(input())
a = [int(input()) for _ in range(n)]
s = sum(a)
mn, mx = min(a), max(a)
mx_k = mx + m
m -= mx * n - s
if m > 0:
    mx += m // n
    mx += 1 if m % n else 0
print(mx, mx_k)


n=int(input())
m=int(input())
A=[int(input()) for i in range(n)]

A.sort()
ANS2=max(A)+m

while m!=0:
    x=min(A)
    i=0
    while i<n and m!=0:
        if A[i]==x:
            A[i]+=1
            i+=1
            m-=1
        else:
            break

    A.sort()

    
print(max(A),ANS2)


n=int(input().rstrip())
m=int(input().rstrip())
L=[]
for _ in range(n):
    a=int(input().rstrip())
    L.append(a)
max_a=m+max(L)
k=m
while(k):
    L[L.index(min(L))]=min(L)+1
    k=k-1
min_a=max(L)
print(str(min_a)+" "+str(max_a))

n = int(input())
m = int(input())
max_k = 0
sum = 0
min_k = 0
for i in range(n):
    a = int(input())
    sum += a
    min_k = max(min_k, a)

# avg_k = sum / n + (1 if sum % n != 0 else 0)
max_sum = min_k * n
max_k = min_k + m
if max_sum < sum + m:
    m -= (max_sum - sum)
    min_k += m // n + (1 if m % n != 0 else 0)

print(min_k, max_k)




import sys
import math

input = sys.stdin.readline
n = int(input())
m = int(input())
a_list = []
a_max = 0
for _ in range(n):
    a = int(input())
    if a_max < a:
        a_max = a
    a_list.append(a)
tmp = 0
for a in a_list:
    tmp += a_max-a
if tmp >= m:
    a_min = a_max
else:
    a_min = a_max + math.ceil((m-tmp)/n)
print(a_min, a_max+m)


import heapq
N = int(input())
M = int(input())
src = [int(input()) for i in range(N)]

mx = max(src) + M

hq = src[:]
heapq.heapify(hq)

for i in range(M):
    m = heapq.heappop(hq)
    heapq.heappush(hq, m+1)
while hq:
    mn = heapq.heappop(hq)

print(mn, mx)