// Original C++ solution (slower):
#include<iostream>

#include<vector>

#include<string>

#include<algorithm>

#include<cmath>

#include<functional>

#include<map>

#include<cstdlib>

#include<complex>

#include<numeric>

#include<set>

#include<deque>



using namespace std;

using Int = long long;

Int INF = 1LL << 60;

const Int MOD = 1000000000 + 7;



template<int Modulo = MOD> struct Mint {

	Int val;

	constexpr Mint(Int v = 0) noexcept : val(v% Modulo) {

		if (val < 0) v += Modulo;

	}

	constexpr int getmod() { return Modulo; }

	constexpr Mint operator - () const noexcept { return val ? Modulo - val : 0; }

	constexpr Mint operator + (const Mint& r) const noexcept { return Mint(*this) += r; }

	constexpr Mint operator - (const Mint& r) const noexcept { return Mint(*this) -= r; }

	constexpr Mint operator * (const Mint& r) const noexcept { return Mint(*this) *= r; }

	constexpr Mint operator / (const Mint& r) const noexcept { return Mint(*this) /= r; }

	constexpr Mint& operator += (const Mint& r) noexcept {

		val += r.val;

		if (val >= Modulo) val -= Modulo;

		return *this;

	}

	constexpr Mint& operator -= (const Mint& r) noexcept {

		val -= r.val;

		if (val < 0) val += Modulo;

		return *this;

	}

	constexpr Mint& operator *= (const Mint& r) noexcept {

		val = val * r.val % Modulo;

		return *this;

	}

	constexpr Mint& operator /= (const Mint& r) noexcept {

		Int a = r.val, b = Modulo, u = 1, v = 0;

		while (b) {

			Int t = a / b;

			a -= t * b; swap(a, b);

			u -= t * v; swap(u, v);

		}

		val = val * u % Modulo;

		if (val < 0) val += Modulo;

		return *this;

	}

	constexpr bool operator == (const Mint& r) const noexcept {

		return this->val == r.val;

	}

	constexpr bool operator != (const Mint& r) const noexcept {

		return this->val != r.val;

	}

	friend ostream& operator << (ostream& os, const Mint<Modulo>& x) noexcept {

		return os << x.val;

	}

	friend istream& operator >> (istream& is, Mint<Modulo>& x) noexcept {

		Int tmp; is >> tmp;

		x = Mint<Modulo>(tmp);

		return is;

	}

	friend constexpr Mint<Modulo> modpow(const Mint<Modulo>& a, Int n) noexcept {

		Mint res(1), tmp = a;

		while (n > 0) {

			if (n & 1) res *= tmp;

			tmp *= tmp;

			n >>= 1;

		}

		return res;

	}

};



using mint = Mint<>;



int main() {



	cin.tie(nullptr);

	ios::sync_with_stdio(false);



	Int N, A;

	cin >> N >> A;



	vector<Int> x(N);

	for (Int i = 0; i < N; i++) {

		cin>>x[i];

	}



	vector<vector<vector<Int>>> dp(N + 1, vector<vector<Int>>(N + 1, vector<Int>(3000)));

	dp[0][0][0] = 1;



	for (Int i = 0; i < N; i++) {

		for (Int j = 0; j < N; j++) {

			for (Int k = 0; k < 3000; k++) {

				//選ばない

				dp[i + 1][j][k] += dp[i][j][k];

				//選ぶ

				if (k - x[i] >= 0) {

					dp[i + 1][j + 1][k] += dp[i][j][k - x[i]];

				}

			}

		}

	}



	Int ans = 0;

	for (Int j = 1; j <= N; j++) {

		ans += dp[N][j][A * j];

	}

	cout << ans << "\n";

}

// Optimized solution to the same problem (faster):
#include<iostream>

#include<vector>

#include<string>

#include<algorithm>

#include<cmath>

#include<functional>

#include<map>

#include<cstdlib>

#include<complex>

#include<numeric>

#include<set>

#include<deque>



using namespace std;

using Int = long long;

Int INF = 1LL << 60;

const Int MOD = 1000000000 + 7;



template<int Modulo = MOD> struct Mint {

	Int val;

	constexpr Mint(Int v = 0) noexcept : val(v% Modulo) {

		if (val < 0) v += Modulo;

	}

	constexpr int getmod() { return Modulo; }

	constexpr Mint operator - () const noexcept { return val ? Modulo - val : 0; }

	constexpr Mint operator + (const Mint& r) const noexcept { return Mint(*this) += r; }

	constexpr Mint operator - (const Mint& r) const noexcept { return Mint(*this) -= r; }

	constexpr Mint operator * (const Mint& r) const noexcept { return Mint(*this) *= r; }

	constexpr Mint operator / (const Mint& r) const noexcept { return Mint(*this) /= r; }

	constexpr Mint& operator += (const Mint& r) noexcept {

		val += r.val;

		if (val >= Modulo) val -= Modulo;

		return *this;

	}

	constexpr Mint& operator -= (const Mint& r) noexcept {

		val -= r.val;

		if (val < 0) val += Modulo;

		return *this;

	}

	constexpr Mint& operator *= (const Mint& r) noexcept {

		val = val * r.val % Modulo;

		return *this;

	}

	constexpr Mint& operator /= (const Mint& r) noexcept {

		Int a = r.val, b = Modulo, u = 1, v = 0;

		while (b) {

			Int t = a / b;

			a -= t * b; swap(a, b);

			u -= t * v; swap(u, v);

		}

		val = val * u % Modulo;

		if (val < 0) val += Modulo;

		return *this;

	}

	constexpr bool operator == (const Mint& r) const noexcept {

		return this->val == r.val;

	}

	constexpr bool operator != (const Mint& r) const noexcept {

		return this->val != r.val;

	}

	friend ostream& operator << (ostream& os, const Mint<Modulo>& x) noexcept {

		return os << x.val;

	}

	friend istream& operator >> (istream& is, Mint<Modulo>& x) noexcept {

		Int tmp; is >> tmp;

		x = Mint<Modulo>(tmp);

		return is;

	}

	friend constexpr Mint<Modulo> modpow(const Mint<Modulo>& a, Int n) noexcept {

		Mint res(1), tmp = a;

		while (n > 0) {

			if (n & 1) res *= tmp;

			tmp *= tmp;

			n >>= 1;

		}

		return res;

	}

};



using mint = Mint<>;



int main() {



	cin.tie(nullptr);

	ios::sync_with_stdio(false);



	Int N, A;

	cin >> N >> A;



	vector<Int> x(N);

	for (Int i = 0; i < N; i++) {

		cin>>x[i];

	}



	vector<vector<vector<Int>>> dp(N + 1, vector<vector<Int>>(N + 1, vector<Int>(2501)));

	dp[0][0][0] = 1;



	for (Int i = 0; i < N; i++) {

		for (Int j = 0; j < N; j++) {

			for (Int k = 0; k < 2501; k++) {

				//選ばない

				dp[i + 1][j][k] += dp[i][j][k];

				//選ぶ

				if (k - x[i] >= 0) {

					dp[i + 1][j + 1][k] += dp[i][j][k - x[i]];

				}

			}

		}

	}



	Int ans = 0;

	for (Int j = 1; j <= N; j++) {

		ans += dp[N][j][A * j];

	}

	cout << ans << "\n";

}

// Fastest known solution for this problem: