#include <iostream>
#include <vector>
#include <algorithm>
#include <utility>
#include <fstream>
#include <unordered_map>
using namespace std;

ifstream fin("oite.in");
ofstream fout("oite.out");

int l, n, ans;

vector<int> o(1025);

unordered_map<int, vector<pair<int, int>>> map;

unordered_map<int, int> cnt;

struct str
{
	int a, b, c, d;
};

vector<str> sol;

#define v1 o[value.first]
#define v2 o[value.second]
#define v3 o[value2.first]
#define v4 o[value2.second]

#define i1 value.first
#define i2 value.second
#define i3 value2.first
#define i4 value2.second

int verificat(str x)
{
	for (int i = 0; i < sol.size(); i++)
		if (x.a == sol[i].a && x.b == sol[i].b && x.c == sol[i].c && x.d == sol[i].d)
			return 0;
	return 1;
}

int main()
{
	fin >> n >> l;

	for (int i = 0; i < n; ++i)
	{
		fin >> o[i];

		cnt[o[i]]++;
	}

	sort(o.begin(), o.begin() + n);

	for (int i = 0; i < n - 1; ++i)
		for (int j = i + 1; j < n; ++j)
		{
			int s = o[i] + o[j];

			pair<int, int> p;

			p.first = i;  p.second = j;

			const auto search = map.find(s);

			int c = 0;

			if (search != map.end())
				for (const auto value : search->second)
					if ((value.first == p.first && value.second == p.second) || value.second == p.first && value.first == p.second)
					{
						c = 1;

						break;
					}

			if (c == 0)
				map[s].push_back(p);
		}

	for (auto i = map.begin(); i != map.end(); i++)
	{
		const auto search1 = map.find(i->first);

		const auto search2 = map.find(l - i->first);

		if (search1 == map.end() || search2 == map.end())
			continue;

		for (const auto value : search1->second)
			for (const auto value2 : search2->second)
			{
				vector<int>sortare(4);

				unordered_map<int, int> poz;

				sortare[0] = i1;  sortare[1] = i2;  sortare[2] = i3;  sortare[3] = i4;

				sort(sortare.begin(), sortare.end());

				for (int j = 0; j < 4; j++)
					poz[sortare[j]]++;

				if (poz[sortare[0]] != 1 || poz[sortare[1]] != 1 || poz[sortare[2]] != 1 || poz[sortare[3]] != 1)
					continue;

				str x;  x.a = sortare[0];  x.b = sortare[1]; x.c = sortare[2];  x.d = sortare[3];

				if (sol.empty() || verificat(x))
				{
					sol.push_back(x);

					ans++;
				}
			}
	}

	fout << ans;
}