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.IOException;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.io.*;

/**
 * http://codeforces.com/problemset/problem/1042/A #sortings
 *
 * Sort (a). Maximum k will always happen if all m people sit on the bench with
 * max a[i]. For minimum k, calculate how many people are required to fill all
 * of the benches to the value of max(a[i]). After that, value of minK will
 * increase by one for every group of n people.
 * 
 * Time complexity: O(n+m)
 */
public class Benches {

	public static void main(String[] args) throws IOException {
		Reader r = new Reader();
		Writer w = new Writer();

		int n = r.nextInt();
		int m = r.nextInt();

		int[] a = r.nextIntArray(n);

		Sortings.countSort(a, 0, 100, SortOrdering.ASCENDING);

		int maxK = a[a.length - 1] + m;

		int diff = 0;
		for (int i = 0; i < a.length; ++i)
			diff += a[a.length - 1] - a[i];

		int add = (m > diff) ? (m - diff) / n : 0;
		if ((m > diff) && ((m - diff) % n != 0))
			++add;

		int minK = a[a.length - 1] + add;

		w.println(minK + " " + maxK);

		w.close();
	}

}

/**
 * Desired ordering of elements when sorting.
 */
enum SortOrdering {
	ASCENDING, DESCENDING
}

/**
 * Class containing preprocessing methods such as prefix sum.
 */
class PreProcessing {

	/**
	 * Transforms given array to prefix sum.
	 * 
	 * array[i] will contain sum of all elements array[0]..array[i].
	 * 
	 * Complexity: O(n)
	 * 
	 * @param array Array of longs to be transformed.
	 */
	public static void prefixSum(long[] array) {
		for (int i = 1; i < array.length; ++i)
			array[i] += array[i - 1];
	}

	/**
	 * Transforms given array to prefix sum.
	 * 
	 * array[i] will contain sum of all elements array[0]..array[i].
	 * 
	 * Complexity: O(n)
	 * 
	 * @param array Array of integers to be transformed.
	 */
	public static void prefixSum(int[] array) {
		for (int i = 1; i < array.length; ++i)
			array[i] += array[i - 1];
	}
}


class Sortings {
	// TODO BucketSort, RadixSort
	// Write note to use Collections.sort() for stable mergesort O(nlgn)

	/**
	 * Sorts given array of N integers in ascending order in linear time using
	 * counting sort. Each element of the array must have value in range
	 * [minValue,maxValue]. Note that this sort is stable. Note M = maxValue -
	 * minValue + 1.
	 * 
	 * Time complexity: O(N + M)
	 * 
	 * Memory complexity: O(N + M)
	 * 
	 * @param arr      Array to be sorted.
	 * @param minValue Minimum possible value for any element in array.
	 * @param maxValue Maximum possible value for any element in array.
	 * @param ordering Desired ordering of the elements.
	 */
	public static void countSort(int[] arr, int minValue, int maxValue, SortOrdering ordering) {
		int range = maxValue - minValue + 1;
		int[] count = new int[range];
		int[] output = new int[arr.length];

		for (int i = 0; i < arr.length; ++i)
			++count[arr[i] - minValue];

		PreProcessing.prefixSum(count);

		for (int i = arr.length - 1; i >= 0; --i) {
			output[count[arr[i] - minValue] - 1] = arr[i];
			--count[arr[i] - minValue];
		}

		for (int i = 0; i < arr.length; ++i)
			if (ordering == SortOrdering.ASCENDING)
				arr[i] = output[i];
			else
				arr[i] = output[arr.length - i - 1];
	}
}


/**
 * Custom class used for fast output.
 */
class Writer {
	private final BufferedWriter bw;

	public Writer() {
		this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
	}

	public void print(Object object) throws IOException {
		bw.append("" + object);
	}

	public void println(Object object) throws IOException {
		print(object);
		bw.append("\n");
	}

	public void close() throws IOException {
		bw.close();
	}

}


/**
 * Custom class for fast input that uses BufferedReader and StringTokenizer.
 */
class Reader {
	private BufferedReader br;
	private StringTokenizer st;

	public Reader() {
		br = new BufferedReader(new InputStreamReader(System.in));
	}

	private String next() {
		while (st == null || !st.hasMoreElements()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return st.nextToken();
	}

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

	public int[] nextIntArray(int size) {
		int[] arr = new int[size];
		for (int i = 0; i < size; ++i)
			arr[i] = nextInt();
		return arr;
	}

	public ArrayList<Integer> nextIntArrayList(int size) {
		ArrayList<Integer> lst = new ArrayList<>(size);
		for (int i = 0; i < size; ++i)
			lst.add(nextInt());
		return lst;
	}

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

	public long[] nextLongArray(int size) {
		long[] arr = new long[size];
		for (int i = 0; i < size; ++i)
			arr[i] = nextLong();
		return arr;
	}

	public ArrayList<Long> nextLongArrayList(int size) {
		ArrayList<Long> lst = new ArrayList<>(size);
		for (int i = 0; i < size; ++i)
			lst.add(nextLong());
		return lst;
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	}

	public double[] nextDoubleArray(int size) {
		double[] arr = new double[size];
		for (int i = 0; i < size; ++i)
			arr[i] = nextDouble();
		return arr;
	}

	public String nextString() {
		return next();
	}

	public String nextLine() {
		String str = "";
		try {
			str = br.readLine();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return str;
	}
}
