#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int MOD = 1e9 + 7;

int n, a;
int x[205];
ll ans = 0;

void backtrack(int i, int current_sum, int count) {
    if (i == n + 1) {
        if (count > 0 && current_sum == 0) {
            ans = (ans + 1) % MOD;
        }
        return;
    }
    // Chọn phần tử thứ i
    backtrack(i + 1, current_sum + x[i] - a, count + 1);
    // Không chọn phần tử thứ i
    backtrack(i + 1, current_sum, count);
}

void solve() {
    cin >> n >> a;
    for (int i = 1; i <= n; i++) cin >> x[i];
    ans = 0;
    backtrack(1, 0, 0);
    cout << ans << endl;
}

int main() {
    int t; cin >> t;
    while (t--) solve();
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

const int MOD = 1e9 + 7;
const int MAXN = 200;
const int MAXA = 200;
const int SHIFT = MAXN * MAXA; // Khoảng giá trị tổng có thể là [-40000, 40000]

int dp[MAXN + 1][2 * SHIFT + 1];

void solve() {
    int n, a;
    cin >> n >> a;
    vector<int> x(n);
    for (int i = 0; i < n; i++) cin >> x[i];

    // Khởi tạo bảng DP
    for (int i = 0; i <= n; i++) {
        fill(dp[i], dp[i] + 2 * SHIFT + 1, 0);
    }
    dp[0][SHIFT] = 1;

    for (int i = 1; i <= n; i++) {
        int diff = x[i - 1] - a;
        for (int j = 0; j <= 2 * SHIFT; j++) {
            // Cách 1: Không chọn x[i-1]
            dp[i][j] = dp[i - 1][j];
            // Cách 2: Có chọn x[i-1]
            if (j - diff >= 0 && j - diff <= 2 * SHIFT) {
                dp[i][j] = (dp[i][j] + dp[i - 1][j - diff]) % MOD;
            }
        }
    }

    // Đáp án là số cách chọn (bất kỳ subset nào) có tổng bằng 0, trừ đi 1 (trường hợp subset rỗng)
    cout << (dp[n][SHIFT] - 1 + MOD) % MOD << endl;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int T;
    cin >> T;
    while (T--) solve();
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

const int MOD = 1e9 + 7;
const int MAXN = 200;
const int MAXA = 200;
const int SHIFT = 200 * 200;
const int MAX_SUM = 2 * SHIFT + 1;

int dp[MAX_SUM];

void solve() {
    int n, a;
    cin >> n >> a;
    vector<int> x(n);
    for (int i = 0; i < n; i++) cin >> x[i];

    // Reset DP array
    memset(dp, 0, sizeof(dp));
    dp[SHIFT] = 1; // Khởi tạo tổng 0 (subset rỗng)

    for (int i = 0; i < n; i++) {
        int diff = x[i] - a;
        // Duyệt ngược để tránh dùng lại phần tử đang xét (knapsack style)
        // Hoặc duyệt xuôi với mảng phụ, nhưng với bài toán subset sum thì duyệt ngược thường dùng mảng 1D
        // Tuy nhiên, công thức $dp[s] = dp[s] + dp[s - diff]$ nếu duyệt xuôi sẽ tính đúng vì ta đang xét thêm 1 phần tử mới
        // Nhưng cẩn thận với việc tính toán:
        // Nếu dùng mảng 1D và cập nhật tại chỗ, ta phải duyệt tổng từ cao xuống thấp nếu diff > 0 (để tránh dùng lại phần tử mới).
        // Ở đây bài toán là đếm subset, không phải số cách (với số lượng phần tử không giới hạn).
        // Với đếm subset, ta dùng mảng 2 chiều hoặc mảng 1 chiều với thứ tự duyệt hợp lý.
        // Đơn giản nhất là dùng mảng 2 chiều, hoặc mảng 1 chiều nhưng duyệt tổng hợp lý.
        // 
        // Cách tiếp cận mảng 1 chiều chuẩn cho subset sum:
        // Duyệt tổng s từ MAX_SUM-1 về 0:
        //   dp[s] = (dp[s] + dp[s - diff]) % MOD;
        // (Cần kiểm tra điều kiện biên)

        vector<int> new_dp(dp, dp + MAX_SUM);
        for (int s = 0; s < MAX_SUM; s++) {
            if (dp[s] != 0) {
                int next_s = s + diff;
                if (next_s >= 0 && next_s < MAX_SUM) {
                    new_dp[next_s] = (new_dp[next_s] + dp[s]) % MOD;
                }
            }
        }
        memcpy(dp, new_dp.data(), sizeof(dp));
    }

    cout << (dp[SHIFT] - 1 + MOD) % MOD << endl;
}

int main() {
    int t; cin >> t;
    while (t--) solve();
    return 0;
}