#include<iostream>
#include<math.h>
#include<algorithm>
using namespace std;
#define int long long

const int N = 2e5 + 5, p = 1e9 + 7;
pair<int, int> nums[N], heap[N];
int ans, arr[N], Logarr[N], dLog[N];

bool smaller(pair<int, int> a, pair<int, int> b)
{
	double x = log2(nums[a.first].first) + nums[a.first].second;
	double y = log2(nums[b.first].first) + nums[b.first].second;
	if (x < y) return true; else return false;
}

void heapInsert(int idx)
{
	while (idx != 0 && smaller(heap[idx], heap[idx / 2]))
	{
		pair<int, int> tmp = heap[idx]; heap[idx] = heap[idx / 2];
		heap[idx / 2] = tmp; idx = idx / 2;
	}
}

void heapify(int idx, int size)
{
	int l = 2 * idx;
	while (l <= size)
	{
		int mini = l + 1 <= size && smaller
			(heap[l + 1], heap[l]) ? l + 1 : l;
		if (smaller(heap[idx], heap[mini])) break;
		pair<int, int> tmp = heap[mini]; heap[mini] = heap[idx];
		heap[idx] = tmp; idx = mini; l = 2 * idx;
	}
}

int power(int a, int b)
{
	int tmp = 2, ans = 1;
	while (b > 0)
	{
		if (b % 2) ans = (ans * tmp) % p;
		tmp = (tmp * tmp) % p; b /= 2;
	}
	return (a * ans) % p;
}

//小根堆维护最小值
//signed main()
//{
//	int n, k; cin >> n >> k;
//	for (int i = 1; i <= n; i++)
//	{
//		cin >> nums[i].first;
//		nums[i].second = 0;
//		heap[i] = { i, nums[i].first };
//		heapInsert(i);
//	}
//
//	for (int i = 0; i < k; i++)
//	{
//		//时间复杂度O(k*logn)，k比较大时无法在时限内得到结果
//		heap[1].second = (heap[1].second * 2) % p;
//		nums[heap[1].first].second++; heapify(1, n);
//	}
//
//	for (int i = 1; i <= n; i++)
//	{
//		ans += heap[i].second; ans %= p;
//	}
//	cout << ans;
//
//	return 0;
//}

signed main()
{
	int n, k; cin >> n >> k;
	for (int i = 1; i <= n; i++)
	{
		cin >> arr[i];
	}
	sort(arr + 1, arr + n + 1);
	for (int i = 1; i <= n; i++)
	{
		Logarr[i] = log2(arr[i]);
	}

	//dLog[i]表示把前i个数的log2值都变成
	//log2(arr[i])所需要的操作次数
	for (int i = 1; i <= n; i++)
	{
		dLog[i] = dLog[i - 1] + (i - 1) *
			(Logarr[i] - Logarr[i - 1]);
	}

	int stop = n, times = 0;
	for (int i = 1; i <= n; i++)
	{
		if (k < dLog[i])
		{
			stop = i - 1; break;
		}
	}
	times = k - dLog[stop];

	//先把前stop - 1个数都不断乘而直至它们的log2值都等于log2(arr[stop])
	//再把剩下的操作次数(times)***队前优先平均***分给前stop个数
	//由于可以使用快速幂，所以会比小根堆的实现更快
	for (int i = 1; i < stop; i++)
	{
		arr[i] = power(arr[i], Logarr[stop] - Logarr[i]);
	}
	int t = times / stop, s = times - t * stop;
	for (int i = 1; i <= stop; i++)
	{
		if (i <= s) arr[i] = power(arr[i], t + 1);
		else arr[i] = power(arr[i], t);
	}

	for (int i = 1; i <= n; i++)
	{
		ans += arr[i]; ans %= p;
	}
	cout << ans;

	return 0;
}