#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>

typedef unsigned long ulong;

template <typename T>
void sort_and_unique(std::vector<T>& v)
{
	std::sort(v.begin(), v.end());

	v.erase(std::unique(v.begin(), v.end()), v.end());
}

int main()
{
	size_t N;

	ulong M;

	assert(std::cin);

	std::cin >> N >> M;

	assert(1 <= N && N <= 1000);

	assert(1 <= M && M <= 200000000);

	// allows 1 throw

	std::vector<ulong> s1(1, 0); // 0 point == no throw

	s1.reserve(N + 1);

	for (size_t i = 0; i < N; ++i)
	{
		ulong p;

		assert(std::cin);

		std::cin >> p;

		assert(1 <= p && p <= 100000000);

		if (p <= M)
		{
			s1.push_back(p);
		}
	}

	sort_and_unique(s1);

	// allows 2 throw

	std::vector<ulong> s2;

	s2.reserve(s1.size() * s1.size());

	for (size_t i = 0; i < s1.size(); ++i)
	{
		for (size_t j = 0; j < s1.size() && s1[i] + s1[j] <= M; ++j)
		{
			s2.push_back(s1[i] + s1[j]);
		}
	}

	sort_and_unique(s2);

	// allows 4 throw

	ulong max_point = 0;

	std::vector<ulong>::reverse_iterator rit = s2.rbegin();

	for (std::vector<ulong>::iterator it = s2.begin(); it != s2.end(); ++it)
	{
		while (rit != s2.rend() && *it + *rit > M)
		{
			++rit;
		}

		if (rit == s2.rend())
		{
			break;
		}

		max_point = std::max(max_point, *it + *rit);
	}

	std::cout << max_point << std::endl;
}