stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

typedef long long LL;

const int maxn=52;

int n,k;

int a[maxn],sum[maxn];

LL dp[3][maxn][maxn*maxn];



int main() {

    scanf("%d%d",&n,&k);

    for (int i=1;i<=n;i++) scanf("%d",&a[i]),sum[i]=sum[i-1]+a[i];

    memset(dp,0,sizeof(dp));

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

    int now=0;

    for (int i=1;i<=n;i++) {

        for (int j=1;j<=i;j++)

            for (int k=0;k<=sum[i];k++) {

                dp[now][j][k]=dp[now^1][j][k];

                if (k>=a[i]) dp[now][j][k]+=dp[now^1][j-1][k-a[i]];

            }

        now^=1;

    }



    LL ans=0;

    for (int i=1;i<=n;i++) ans+=dp[now^1][i][i*k];

    printf("%lld\n",ans);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 3.50653886463557x):
#include <algorithm>

#include <iostream>

#include <cstdio>

#include <cstring>

#include <cmath>

#include <bitset>

typedef long long ll;

using namespace std;

int n,a;

ll dp[52][52][2550];

int num[55];

int main(){

	scanf("%d%d",&n,&a);

	for(int i=1;i<=n;i++) scanf("%d",&num[i]);

	dp[1][1][num[1]]=1;

	for(int i=2;i<=n;i++){

		dp[i][1][num[i]]=1;

		for(int f=1;f<=i;f++){

			for(int j=1;j<i;j++){

				for(int k=1;k<=(j*50);k++){

					dp[i][f][num[i]+k]+=dp[j][f-1][k];

				}

			}

		}

	}

	ll ans=0;

	for(int i=1;i<=n;i++){

		for(int j=1;j<=i;j++){

			ans+=dp[i][j][j*a];

		}

	}

	printf("%lld\n",ans);

	return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<cstring>

long long arr[55];

long long dp[55][2505];

int main()

{

    int N,A;

    scanf("%d%d",&N,&A);

    for(int i=0; i<N; i++)

    {

        scanf("%lld",&arr[i]);

    }

    memset(dp,0,sizeof(dp));

    dp[0][0]=1;

    for(int i=1; i<=N; i++)

    {

        for(int k=i; k>0; k--)

        {

            for(int j=arr[i-1]; j<=2500; j++)

            {

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

            }

        }

    }

    long long sum=0;

    for(int i=1; i<=N; i++)

    {

        sum+=dp[i][A*i];

    }

    printf("%lld\n",sum);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.3439596240300393x):
#include <algorithm>

#include <iostream>

#include <cstdio>

#include <cstring>

#include <cmath>

#include <bitset>

typedef long long ll;

using namespace std;

int n,a;

ll dp[52][52][2550];

int num[55];

int main(){

	scanf("%d%d",&n,&a);

	for(int i=1;i<=n;i++) scanf("%d",&num[i]);

	dp[1][1][num[1]]=1;

	for(int i=2;i<=n;i++){

		dp[i][1][num[i]]=1;

		for(int f=1;f<=i;f++){

			for(int j=1;j<i;j++){

				for(int k=1;k<=(j*50);k++){

					dp[i][f][num[i]+k]+=dp[j][f-1][k];

				}

			}

		}

	}

	ll ans=0;

	for(int i=1;i<=n;i++){

		for(int j=1;j<=i;j++){

			ans+=dp[i][j][j*a];

		}

	}

	printf("%lld\n",ans);

	return 0;

}
// Slower C++ solution:
#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

typedef long long LL;

const int maxn=52;

int n,k;

int a[maxn],sum[maxn];

LL dp[3][maxn][maxn*maxn];



int main() {

    scanf("%d%d",&n,&k);

    for (int i=1;i<=n;i++) scanf("%d",&a[i]),sum[i]=sum[i-1]+a[i];

    memset(dp,0,sizeof(dp));

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

    int now=0;

    for (int i=1;i<=n;i++) {

        for (int j=1;j<=i;j++)

            for (int k=0;k<=sum[i];k++) {

                dp[now][j][k]=dp[now^1][j][k];

                if (k>=a[i]) dp[now][j][k]+=dp[now^1][j-1][k-a[i]];

            }

        now^=1;

    }



    LL ans=0;

    for (int i=1;i<=n;i++) ans+=dp[now^1][i][i*k];

    printf("%lld\n",ans);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.7236591716735061x):
#include <algorithm>

#include <iostream>

#include <cstdio>

#include <cstring>

#include <cmath>

#include <bitset>

typedef long long ll;

using namespace std;

int n,a;

ll dp[52][52][2555];

int num[55];

int main(){

    scanf("%d%d",&n,&a);

    for(int i=1;i<=n;i++) scanf("%d",&num[i]);

    dp[1][1][num[1]]=1;

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

    for(int i=2;i<=n;i++){

        dp[i][1][num[i]]++;

        for(int j=1;j<=i;j++){

            for(int k=1;k<=(i*50);k++){

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

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

            }

        }

    }

    ll ans=0;

    for(int i=1;i<=n;i++){

        ans+=dp[n][i][i*a];

    }

    printf("%lld\n",ans);

    return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<cstring>

long long arr[55];

long long dp[55][2505];

int main()

{

    int N,A;

    scanf("%d%d",&N,&A);

    for(int i=0; i<N; i++)

    {

        scanf("%lld",&arr[i]);

    }

    memset(dp,0,sizeof(dp));

    dp[0][0]=1;

    for(int i=1; i<=N; i++)

    {

        for(int k=i; k>0; k--)

        {

            for(int j=arr[i-1]; j<=2500; j++)

            {

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

            }

        }

    }

    long long sum=0;

    for(int i=1; i<=N; i++)

    {

        sum+=dp[i][A*i];

    }

    printf("%lld\n",sum);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 0.8120684148763254x):
#include <algorithm>

#include <iostream>

#include <cstdio>

#include <cstring>

#include <cmath>

#include <bitset>

typedef long long ll;

using namespace std;

int n,a;

ll dp[52][52][2555];

int num[55];

int main(){

    scanf("%d%d",&n,&a);

    for(int i=1;i<=n;i++) scanf("%d",&num[i]);

    dp[1][1][num[1]]=1;

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

    for(int i=2;i<=n;i++){

        dp[i][1][num[i]]++;

        for(int j=1;j<=i;j++){

            for(int k=1;k<=(i*50);k++){

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

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

            }

        }

    }

    ll ans=0;

    for(int i=1;i<=n;i++){

        ans+=dp[n][i][i*a];

    }

    printf("%lld\n",ans);

    return 0;

}
// Slower C++ solution:
#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

typedef long long LL;

const int maxn=52;

int n,k;

int a[maxn],sum[maxn];

LL dp[3][maxn][maxn*maxn];



int main() {

    scanf("%d%d",&n,&k);

    for (int i=1;i<=n;i++) scanf("%d",&a[i]),sum[i]=sum[i-1]+a[i];

    memset(dp,0,sizeof(dp));

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

    int now=0;

    for (int i=1;i<=n;i++) {

        for (int j=1;j<=i;j++)

            for (int k=0;k<=sum[i];k++) {

                dp[now][j][k]=dp[now^1][j][k];

                if (k>=a[i]) dp[now][j][k]+=dp[now^1][j-1][k-a[i]];

            }

        now^=1;

    }



    LL ans=0;

    for (int i=1;i<=n;i++) ans+=dp[now^1][i][i*k];

    printf("%lld\n",ans);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.2863825522398395x):
#include <bits/stdc++.h>



using namespace std;



long long dp[55][55][2555];

long long a[55];



int main(){

	int n, A;

	scanf("%d %d", &n, &A);

	for (int i = 0; i < n; i++){

		scanf("%lld", a + i);

	}

	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++){

				if (dp[i][j][k]){

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

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

				}

			}

		}

	}

	long long ans = 0;

	for (int i = 1; i <= n; i++){

		ans += dp[n][i][i * A];

	}

	printf("%lld\n", ans);

	return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<cstring>

long long arr[55];

long long dp[55][2505];

int main()

{

    int N,A;

    scanf("%d%d",&N,&A);

    for(int i=0; i<N; i++)

    {

        scanf("%lld",&arr[i]);

    }

    memset(dp,0,sizeof(dp));

    dp[0][0]=1;

    for(int i=1; i<=N; i++)

    {

        for(int k=i; k>0; k--)

        {

            for(int j=arr[i-1]; j<=2500; j++)

            {

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

            }

        }

    }

    long long sum=0;

    for(int i=1; i<=N; i++)

    {

        sum+=dp[i][A*i];

    }

    printf("%lld\n",sum);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 0.6060540606225145x):
#include <bits/stdc++.h>



using namespace std;



long long dp[55][55][2555];

long long a[55];



int main(){

	int n, A;

	scanf("%d %d", &n, &A);

	for (int i = 0; i < n; i++){

		scanf("%lld", a + i);

	}

	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++){

				if (dp[i][j][k]){

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

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

				}

			}

		}

	}

	long long ans = 0;

	for (int i = 1; i <= n; i++){

		ans += dp[n][i][i * A];

	}

	printf("%lld\n", ans);

	return 0;

}
// Slower C++ solution:
#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

typedef long long LL;

const int maxn=52;

int n,k;

int a[maxn],sum[maxn];

LL dp[3][maxn][maxn*maxn];



int main() {

    scanf("%d%d",&n,&k);

    for (int i=1;i<=n;i++) scanf("%d",&a[i]),sum[i]=sum[i-1]+a[i];

    memset(dp,0,sizeof(dp));

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

    int now=0;

    for (int i=1;i<=n;i++) {

        for (int j=1;j<=i;j++)

            for (int k=0;k<=sum[i];k++) {

                dp[now][j][k]=dp[now^1][j][k];

                if (k>=a[i]) dp[now][j][k]+=dp[now^1][j-1][k-a[i]];

            }

        now^=1;

    }



    LL ans=0;

    for (int i=1;i<=n;i++) ans+=dp[now^1][i][i*k];

    printf("%lld\n",ans);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.0961415081647274x):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define int ll

#define mn 100005

#define inf 4444444444444444444

#define mod (ll) 1000000007

#define base 31

#define fi first

#define se second

#define pii pair <int, int>

#define pb push_back

#define mp make_pair



//int t, ntest;

int n, k, ans;

int a[55], dp[55][55][2505];



void input(){

	cin>>n>>k;

	for (int i=1; i<=n; i++) {

		cin>>a[i];

	}

}



// i so dau tien, chon j so, tong la t

int d (int i, int j, int t){

	if (j>i) return 0;

	if (j<0 || i<0 || t<0) return 0;

	if (t==0){

		if (j==0) return 1;

		return 0;

	}

	if (j==0 && t!=0) return 0;

	if (dp[i][j][t]<inf) return dp[i][j][t];

	return dp[i][j][t]=d(i-1, j, t)+d(i-1, j-1, t-a[i]);

}



void output(){



}



void solve(){

	for (int i=1; i<=n; i++){

		for (int j=1; j<=n; j++){

			for (int t=1; t<=2500; t++){

				dp[i][j][t]=inf;

			}

		}

	}

	for (int i=1; i<=n; i++){

		ans+=d(n, i, k*i);

	}

	cout<<ans;

}



signed main(){

	ios_base::sync_with_stdio(0);

	cin.tie(0);

//	freopen("test.inp", "r", stdin);

//	freopen("test.out", "w", stdout);

//	cin>>t;

//	for (ntest=1; ntest<=t; ntest++){

		input();

		solve();

		output();

//	}

}



//mtrang_149
// Slower C++ solution:
#include<cstdio>

#include<cstring>

long long arr[55];

long long dp[55][2505];

int main()

{

    int N,A;

    scanf("%d%d",&N,&A);

    for(int i=0; i<N; i++)

    {

        scanf("%lld",&arr[i]);

    }

    memset(dp,0,sizeof(dp));

    dp[0][0]=1;

    for(int i=1; i<=N; i++)

    {

        for(int k=i; k>0; k--)

        {

            for(int j=arr[i-1]; j<=2500; j++)

            {

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

            }

        }

    }

    long long sum=0;

    for(int i=1; i<=N; i++)

    {

        sum+=dp[i][A*i];

    }

    printf("%lld\n",sum);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 0.8033932210586257x):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define int ll

#define mn 100005

#define inf 4444444444444444444

#define mod (ll) 1000000007

#define base 31

#define fi first

#define se second

#define pii pair <int, int>

#define pb push_back

#define mp make_pair



//int t, ntest;

int n, k, ans;

int a[55], dp[55][55][2505];



void input(){

	cin>>n>>k;

	for (int i=1; i<=n; i++) {

		cin>>a[i];

	}

}



// i so dau tien, chon j so, tong la t

int d (int i, int j, int t){

	if (j>i) return 0;

	if (j<0 || i<0 || t<0) return 0;

	if (t==0){

		if (j==0) return 1;

		return 0;

	}

	if (j==0 && t!=0) return 0;

	if (dp[i][j][t]<inf) return dp[i][j][t];

	return dp[i][j][t]=d(i-1, j, t)+d(i-1, j-1, t-a[i]);

}



void output(){



}



void solve(){

	for (int i=1; i<=n; i++){

		for (int j=1; j<=n; j++){

			for (int t=1; t<=2500; t++){

				dp[i][j][t]=inf;

			}

		}

	}

	for (int i=1; i<=n; i++){

		ans+=d(n, i, k*i);

	}

	cout<<ans;

}



signed main(){

	ios_base::sync_with_stdio(0);

	cin.tie(0);

//	freopen("test.inp", "r", stdin);

//	freopen("test.out", "w", stdout);

//	cin>>t;

//	for (ntest=1; ntest<=t; ntest++){

		input();

		solve();

		output();

//	}

}



//mtrang_149
// Slower C++ solution:
#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

typedef long long LL;

const int maxn=52;

int n,k;

int a[maxn],sum[maxn];

LL dp[3][maxn][maxn*maxn];



int main() {

    scanf("%d%d",&n,&k);

    for (int i=1;i<=n;i++) scanf("%d",&a[i]),sum[i]=sum[i-1]+a[i];

    memset(dp,0,sizeof(dp));

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

    int now=0;

    for (int i=1;i<=n;i++) {

        for (int j=1;j<=i;j++)

            for (int k=0;k<=sum[i];k++) {

                dp[now][j][k]=dp[now^1][j][k];

                if (k>=a[i]) dp[now][j][k]+=dp[now^1][j-1][k-a[i]];

            }

        now^=1;

    }



    LL ans=0;

    for (int i=1;i<=n;i++) ans+=dp[now^1][i][i*k];

    printf("%lld\n",ans);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 3.298805977738704x):
#include<bits/stdc++.h>



#define int long long



using namespace std;



int n;

int f[5000][100];

int g[5000][100];

int a[1001];

int sum;

int dem;

int B;

int res;



void input(){

	cin>>n>>B;

	for(int i=1;i<=n;i++){

		cin>>a[i];

	}

}



void solve(){

	res = 0;

	g[0][0] = 1;

	for(int i=1;i<=n;i++){

		for(int tong=0;tong<=n*50;tong++){

			for(int sl=0;sl<=n;sl++){

				f[tong+a[i]][sl+1]+=g[tong][sl];

				f[tong][sl] += g[tong][sl];

			}

		}

		for(int tong=0;tong<=n*50;tong++){

			for(int sl=0;sl<=n;sl++){

				g[tong][sl] = f[tong][sl];

				f[tong][sl] = 0;

			}

		}

	}

	

	for(int tong=B,sl=1;tong<=n*50;tong+=B,++sl){

		res += g[tong][sl];

	}

}



void output(){

	cout<<res;

}



signed main(){

//	freopen("","r",stdin);



//	int ntest;

//	scanf("%d",&ntest);

//

//	for(int itest=0;itest<ntest;itest++){



		input();

		solve();

		output();



//		printf("\n");



//	}



	return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<cstring>

long long arr[55];

long long dp[55][2505];

int main()

{

    int N,A;

    scanf("%d%d",&N,&A);

    for(int i=0; i<N; i++)

    {

        scanf("%lld",&arr[i]);

    }

    memset(dp,0,sizeof(dp));

    dp[0][0]=1;

    for(int i=1; i<=N; i++)

    {

        for(int k=i; k>0; k--)

        {

            for(int j=arr[i-1]; j<=2500; j++)

            {

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

            }

        }

    }

    long long sum=0;

    for(int i=1; i<=N; i++)

    {

        sum+=dp[i][A*i];

    }

    printf("%lld\n",sum);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.2643413384926274x):
#include<bits/stdc++.h>



#define int long long



using namespace std;



int n;

int f[5000][100];

int g[5000][100];

int a[1001];

int sum;

int dem;

int B;

int res;



void input(){

	cin>>n>>B;

	for(int i=1;i<=n;i++){

		cin>>a[i];

	}

}



void solve(){

	res = 0;

	g[0][0] = 1;

	for(int i=1;i<=n;i++){

		for(int tong=0;tong<=n*50;tong++){

			for(int sl=0;sl<=n;sl++){

				f[tong+a[i]][sl+1]+=g[tong][sl];

				f[tong][sl] += g[tong][sl];

			}

		}

		for(int tong=0;tong<=n*50;tong++){

			for(int sl=0;sl<=n;sl++){

				g[tong][sl] = f[tong][sl];

				f[tong][sl] = 0;

			}

		}

	}

	

	for(int tong=B,sl=1;tong<=n*50;tong+=B,++sl){

		res += g[tong][sl];

	}

}



void output(){

	cout<<res;

}



signed main(){

//	freopen("","r",stdin);



//	int ntest;

//	scanf("%d",&ntest);

//

//	for(int itest=0;itest<ntest;itest++){



		input();

		solve();

		output();



//		printf("\n");



//	}



	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define int ll

#define mn 100005

#define inf 4444444444444444444

#define mod (ll) 1000000007

#define base 31

#define fi first

#define se second

#define pii pair <int, int>

#define pb push_back

#define mp make_pair



//int t, ntest;

int n, k, ans;

int a[55], dp[55][55][2505];



void input(){

	cin>>n>>k;

	for (int i=1; i<=n; i++) {

		cin>>a[i];

	}

}



// i so dau tien, chon j so, tong la t

int d (int i, int j, int t){

	if (j>i) return 0;

	if (j<0 || i<0 || t<0) return 0;

	if (t==0){

		if (j==0) return 1;

		return 0;

	}

	if (j==0 && t!=0) return 0;

	if (dp[i][j][t]<inf) return dp[i][j][t];

	return dp[i][j][t]=d(i-1, j, t)+d(i-1, j-1, t-a[i]);

}



void output(){



}



void solve(){

	for (int i=1; i<=n; i++){

		for (int j=1; j<=n; j++){

			for (int t=1; t<=2500; t++){

				dp[i][j][t]=inf;

			}

		}

	}

	for (int i=1; i<=n; i++){

		ans+=d(n, i, k*i);

	}

	cout<<ans;

}



signed main(){

	ios_base::sync_with_stdio(0);

	cin.tie(0);

//	freopen("test.inp", "r", stdin);

//	freopen("test.out", "w", stdout);

//	cin>>t;

//	for (ntest=1; ntest<=t; ntest++){

		input();

		solve();

		output();

//	}

}



//mtrang_149


// Faster C++ solution for the same problem (measured speedup: 1.5737515644289526x):
#include<bits/stdc++.h>



#define int long long



using namespace std;



int n;

int f[5000][100];

int g[5000][100];

int a[1001];

int sum;

int dem;

int B;

int res;



void input(){

	cin>>n>>B;

	for(int i=1;i<=n;i++){

		cin>>a[i];

	}

}



void solve(){

	res = 0;

	g[0][0] = 1;

	for(int i=1;i<=n;i++){

		for(int tong=0;tong<=n*50;tong++){

			for(int sl=0;sl<=n;sl++){

				f[tong+a[i]][sl+1]+=g[tong][sl];

				f[tong][sl] += g[tong][sl];

			}

		}

		for(int tong=0;tong<=n*50;tong++){

			for(int sl=0;sl<=n;sl++){

				g[tong][sl] = f[tong][sl];

				f[tong][sl] = 0;

			}

		}

	}

	

	for(int tong=B,sl=1;tong<=n*50;tong+=B,++sl){

		res += g[tong][sl];

	}

}



void output(){

	cout<<res;

}



signed main(){

//	freopen("","r",stdin);



//	int ntest;

//	scanf("%d",&ntest);

//

//	for(int itest=0;itest<ntest;itest++){



		input();

		solve();

		output();



//		printf("\n");



//	}



	return 0;

}
// Slower C++ solution:
#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

typedef long long LL;

const int maxn=52;

int n,k;

int a[maxn],sum[maxn];

LL dp[3][maxn][maxn*maxn];



int main() {

    scanf("%d%d",&n,&k);

    for (int i=1;i<=n;i++) scanf("%d",&a[i]),sum[i]=sum[i-1]+a[i];

    memset(dp,0,sizeof(dp));

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

    int now=0;

    for (int i=1;i<=n;i++) {

        for (int j=1;j<=i;j++)

            for (int k=0;k<=sum[i];k++) {

                dp[now][j][k]=dp[now^1][j][k];

                if (k>=a[i]) dp[now][j][k]+=dp[now^1][j-1][k-a[i]];

            }

        now^=1;

    }



    LL ans=0;

    for (int i=1;i<=n;i++) ans+=dp[now^1][i][i*k];

    printf("%lld\n",ans);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.8139472159906873x):
#include <bits/stdc++.h>

using namespace std;



int a[55];



long long dp[55][55][3000];



int main() {

	ios::sync_with_stdio(0);

	cin.tie(0); cout.tie(0);

	int n, A; cin >> n >> A;

	for (int i = 1; i <= n; i++) cin >> a[i];

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

	long long ans = 0;

	for (int i = 0; i <= n; i++) {

		for (int j = 0; j <= i; j++) {

			for (int k = 0; k <= 2500; k++) {

				if (i < n) {

					if (dp[i][j][k]) {

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

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

					}

				}

				else {

					if (A * j == k) ans += dp[i][j][k];

				}

			}

		}

	}

	cout << ans - 1 << endl;

	return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<cstring>

long long arr[55];

long long dp[55][2505];

int main()

{

    int N,A;

    scanf("%d%d",&N,&A);

    for(int i=0; i<N; i++)

    {

        scanf("%lld",&arr[i]);

    }

    memset(dp,0,sizeof(dp));

    dp[0][0]=1;

    for(int i=1; i<=N; i++)

    {

        for(int k=i; k>0; k--)

        {

            for(int j=arr[i-1]; j<=2500; j++)

            {

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

            }

        }

    }

    long long sum=0;

    for(int i=1; i<=N; i++)

    {

        sum+=dp[i][A*i];

    }

    printf("%lld\n",sum);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 0.8546058667321642x):
#include <bits/stdc++.h>

using namespace std;



int a[55];



long long dp[55][55][3000];



int main() {

	ios::sync_with_stdio(0);

	cin.tie(0); cout.tie(0);

	int n, A; cin >> n >> A;

	for (int i = 1; i <= n; i++) cin >> a[i];

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

	long long ans = 0;

	for (int i = 0; i <= n; i++) {

		for (int j = 0; j <= i; j++) {

			for (int k = 0; k <= 2500; k++) {

				if (i < n) {

					if (dp[i][j][k]) {

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

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

					}

				}

				else {

					if (A * j == k) ans += dp[i][j][k];

				}

			}

		}

	}

	cout << ans - 1 << endl;

	return 0;

}
// Slower C++ solution:
#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

typedef long long LL;

const int maxn=52;

int n,k;

int a[maxn],sum[maxn];

LL dp[3][maxn][maxn*maxn];



int main() {

    scanf("%d%d",&n,&k);

    for (int i=1;i<=n;i++) scanf("%d",&a[i]),sum[i]=sum[i-1]+a[i];

    memset(dp,0,sizeof(dp));

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

    int now=0;

    for (int i=1;i<=n;i++) {

        for (int j=1;j<=i;j++)

            for (int k=0;k<=sum[i];k++) {

                dp[now][j][k]=dp[now^1][j][k];

                if (k>=a[i]) dp[now][j][k]+=dp[now^1][j-1][k-a[i]];

            }

        now^=1;

    }



    LL ans=0;

    for (int i=1;i<=n;i++) ans+=dp[now^1][i][i*k];

    printf("%lld\n",ans);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 3.477410907010846x):
#include <bits/stdc++.h>



using namespace std;



const int maxN = 50;

const int maxA = 50;



int N, A;

int x[maxN];

long long f[maxN + 1][maxA * maxN + 1];



int main() {

	ios::sync_with_stdio(false);

	cin.tie(nullptr);

	cout.tie(nullptr);



	cin >> N >> A;

	for (int i = 0; i < N; i++)

		cin >> x[i];



	f[0][0] = 1;

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

		for (int j = i; j >= 0; j--) {

			for (int k = A * N; k >= x[i]; k--)

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

		}

	}



	long long ans = 0;

	for (int i = 1; i <= N; i++)

		ans += f[i][A * i];



	cout << ans << '\n';



	return 0;

}
// Slower C++ solution:
#include<cstdio>

#include<cstring>

long long arr[55];

long long dp[55][2505];

int main()

{

    int N,A;

    scanf("%d%d",&N,&A);

    for(int i=0; i<N; i++)

    {

        scanf("%lld",&arr[i]);

    }

    memset(dp,0,sizeof(dp));

    dp[0][0]=1;

    for(int i=1; i<=N; i++)

    {

        for(int k=i; k>0; k--)

        {

            for(int j=arr[i-1]; j<=2500; j++)

            {

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

            }

        }

    }

    long long sum=0;

    for(int i=1; i<=N; i++)

    {

        sum+=dp[i][A*i];

    }

    printf("%lld\n",sum);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.6383143544487473x):
#include <bits/stdc++.h>



using namespace std;



const int maxN = 50;

const int maxA = 50;



int N, A;

int x[maxN];

long long f[maxN + 1][maxA * maxN + 1];



int main() {

	ios::sync_with_stdio(false);

	cin.tie(nullptr);

	cout.tie(nullptr);



	cin >> N >> A;

	for (int i = 0; i < N; i++)

		cin >> x[i];



	f[0][0] = 1;

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

		for (int j = i; j >= 0; j--) {

			for (int k = A * N; k >= x[i]; k--)

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

		}

	}



	long long ans = 0;

	for (int i = 1; i <= N; i++)

		ans += f[i][A * i];



	cout << ans << '\n';



	return 0;

}