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 ≤ n ≤ 100) — the number of benches in the park.

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

Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ 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.


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class cfq {
	static final double EPS = 1e-9;

	static pair[] x = new pair[3];
	static int ac1 = -1;
	static int ac2 = -1;
	static int noox = -1;
	static int nooy = -1;
	static int same = -1;
	static int grid[][] = new int[1001][1001];
	static long wx1 = 0, wy1 = 0;
	static long wx2 = 0, wy2 = 0;
	static long bx1 = 0, by1 = 0;
	static long bx2 = 0, by2 = 0;
	static long overlappingWS = -1, overlappingWE = -1;
	static long overlappingHS = -1, overlappingHE = -1;

	public static void main(String[] args) throws IOException {

		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int x[] = new int[n];
		int more = sc.nextInt();
		int max = -1;
		for (int i = 0; i < n; i++) {
			x[i] = sc.nextInt();
			max = Math.max(max, x[i]);
		}

		max += more;
		int min = -1;
//		System.out.println(Arrays.toString(x));
		Arrays.sort(x);
//		System.out.println(Arrays.toString(x));
		while (true) {
			for (int i = 0; i < n - 1; i++) {
				if (x[i] < x[n - 1]) {
					int kore = more;
					more -= Math.min(x[n - 1] - x[i], more);
					x[i] += Math.min(x[n - 1] - x[i], kore);
//					System.out.println(Arrays.toString(x));
//					System.out.println(more+" "+(x[n - 1] - x[i]));
//					System.out.println(more);
//					System.out.println(444);
				} else {
//					System.out.println(55);
					if (more > 0) {
						x[i]++;
						more--;
					}
				}
				min = Math.max(min, x[i]);
			}
//			System.out.println(more);
			if (n>1&&x[n - 2] > x[n - 1]) {
				if (more > 0) {
					x[n - 1]++;
					more--;
				}
			}
//			System.out.println(more);
			if(n==1) {
				x[n-1]+=more;
				more=0;
			}
			min = Math.max(min, x[n-1]);
			if (more <= 0) {
				break;
			}
		}
//		System.out.println(Arrays.toString(x));
		System.out.println(min+" "+max);

	}

	static long incWhite(long horiWfrom, long horiWto, long verWfrom, long verWto) {
		long tot = 0;
		tot += horiWto - horiWfrom + 1;
		tot /= 2;
		tot *= (verWto - verWfrom + 1);
		if ((horiWto - horiWfrom + 1) % 2 != 0) {
			if ((even(horiWto) & even(verWfrom)) || (!even(horiWto) & !even(verWfrom))) {
				// white at base
				tot += (verWto - verWfrom + 1) / 2;
			} else {
				tot += (verWto - verWfrom + 1) / 2;
				if ((verWto - verWfrom + 1) % 2 != 0)
					tot++;
			}
		}
		return tot;
	}

	static long incblack(long horiWfrom, long horiWto, long verWfrom, long verWto) {
		long tot = 0;
		tot += horiWto - horiWfrom + 1;
		tot /= 2;
		tot *= (verWto - verWfrom + 1);
		if ((horiWto - horiWfrom + 1) % 2 != 0) {
			if ((even(horiWto) & even(verWfrom)) || (!even(horiWto) & !even(verWfrom))) {
				// white at base
				tot += (verWto - verWfrom + 1) / 2;
				if ((verWto - verWfrom + 1) % 2 != 0)
					tot++;
			} else {
				tot += (verWto - verWfrom + 1) / 2;
			}
		}
		return tot;
	}

	static boolean even(long k) {
		return k % 2 == 0;
	}

	static long getoverlappinghori(long horiBfrom, long horiBto, long horiWfrom, long horiWto) {
		if (horiBfrom >= horiWfrom && horiBto <= horiWto) {
			overlappingWS = horiBfrom;
			overlappingWE = horiBto;
			return horiBto - horiBfrom + 1;
		}
		if (horiWfrom >= horiBfrom && horiWto <= horiBto) {
			overlappingWS = horiWfrom;
			overlappingWE = horiWto;
			return horiWto - horiWfrom + 1;
		}
		if (horiBfrom >= horiWfrom && horiBto >= horiWto) {
			overlappingWS = horiBfrom;
			overlappingWE = horiWto;
			return horiWto - horiBfrom + 1;
		}
		if (horiWfrom >= horiBfrom && horiWto >= horiBto) {
			overlappingWS = horiWfrom;
			overlappingWE = horiBto;
			return horiBto - horiWfrom + 1;
		}

		return 0;
	}

	static long getoverlappingver(long horiBfrom, long horiBto, long horiWfrom, long horiWto) {
		if (horiBfrom >= horiWfrom && horiBto <= horiWto) {
			overlappingHS = horiBfrom;
			overlappingHE = horiBto;
			return horiBto - horiBfrom + 1;
		}
		if (horiWfrom >= horiBfrom && horiWto <= horiBto) {
			overlappingHS = horiWfrom;
			overlappingHE = horiWto;
			return horiWto - horiWfrom + 1;
		}
		if (horiBfrom >= horiWfrom && horiBto >= horiWto) {
			overlappingHS = horiBfrom;
			overlappingHE = horiWto;
			return horiWto - horiBfrom + 1;
		}
		if (horiWfrom >= horiBfrom && horiWto >= horiBto) {
			overlappingHS = horiWfrom;
			overlappingHE = horiBto;
			return horiBto - horiWfrom + 1;
		}

		return 0;
	}

	static long[] shuffle(long[] a) {
		int n = a.length;
		for (int i = 0; i < n; i++) {
			int r = i + (int) (Math.random() * (n - i));
			long tmp = a[i];
			a[i] = a[r];
			a[r] = tmp;
		}
		return a;
	}

	public static class pair implements Comparable<pair> {

		int x, y;

		pair(int a, int b) {
			x = a;
			y = b;
		}

		public int compareTo(pair p) {
			if (Math.abs(x - p.x) > EPS)
				return x > p.x ? 1 : -1;
			if (Math.abs(y - p.y) > EPS)
				return y > p.y ? 1 : -1;
			return 0;
		}
	}

	public static class kair implements Comparable<kair> {

		ArrayList<Integer> ar;
		int s;

		kair(ArrayList<Integer> a, int b) {
			ar = a;
			s = b;
		}

		// desc version
		public int compareTo(kair p) {
			if (Math.abs(s - p.s) > EPS)
				return s < p.s ? 1 : -1;

			return 0;
		}
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public Scanner(String file) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(file));
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public long nextlong() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			long res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}
}