//
// Created by BigBag on 22.07.2023 12:07:50
//

#include <bits/stdc++.h>

#define F first
#define S second
#define MP make_pair
#define PB push_back

#define all(a) a.begin(), a.end()
#define len(a) (int) (a.size())
#define mp make_pair
#define pb push_back
#define fir first
#define sec second

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;

#ifdef Energy_is_not_over
#define DEBUG for (bool ____DEBUG = true; ____DEBUG; ____DEBUG = false)
#define LOG(...) print(#__VA_ARGS__" ::", __VA_ARGS__) << endl

template<class ...Ts>
auto &print(Ts ...ts) { return ((cerr << ts << " "), ...); }

#else
#define DEBUG while (false)
#define LOG(...)
#endif

const int max_n = 111, inf = 1000111222;
const int mod = 1000000007;

inline void inc(int &x, int y) {
    x += y;
    if (x >= mod) {
        x -= mod;
    }
}

inline void dec(int &x, int y) {
    x -= y;
    if (x < 0) {
        x += mod;
    }
}

inline int neg(int x) {
    return x ? (mod - x) : 0;
}

inline int mul(int x) {
    return x;
}

template<typename... Args>
inline int mul(int x, Args... args) {
    return (1LL * x * mul(args...)) % mod;
}

int power(int a, long long b) {
    int res = 1 % mod;
    while (b) {
        if (b % 2) {
            res = mul(res, a);
        }
        b /= 2;
        a = mul(a, a);
    }
    return res;
}

int inv(int x) {
    return power(x, mod - 2);
}

const int max_f = max_n;
const int max_rf = max_f;
static_assert(max_f >= 1 && max_rf >= 1);

int f[max_f], rf[max_rf];

bool frf_calculated = []() {
    f[0] = 1;
    for (int i = 1; i < max_f; ++i) {
        f[i] = mul(i, f[i - 1]);
    }
    int x = f[min(max_f, max_rf) - 1];
    for (int i = max_f; i < max_rf; ++i) {
        x = mul(x, i);
    }
    rf[max_rf - 1] = inv(x);
    for (int i = max_rf - 2; i >= 0; --i) {
        rf[i] = mul(i + 1, rf[i + 1]);
    }
    return true;
}();

int get_c(int n, int k) {
    if (n < k || k < 0) {
        return 0;
    }
    assert(n < max_f && k < max_rf && n - k < max_rf);
    return mul(f[n], rf[k], rf[n - k]);
}

int func(int n) {
    return n * (n + 1) / 2;
}

const int max_s = max_n * max_n / 2;
const bool debug = 0;

int t, n, m, a[max_n], dp[max_n][max_s];

int main() {
//    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    if (debug) {
        t = 50;
    } else {
        cin >> t;
    }
    while (t--) {
        if (debug) {
            n = 100;
            m = 1000000000;
            for (int i = 1; i <= n; ++i) {
                a[i] = 2;
            }
        } else {
            cin >> n >> m;
            for (int i = 1; i <= n; ++i) {
                cin >> a[i];
            }
        }
        a[0] = 1;
        a[n + 1] = 1;
        n += 2;
        memset(dp, 0, sizeof(dp));
        dp[0][0] = 1;
        for (int i = 0; i < n; ++i) {
            for (int s = 0; s <= func(i); ++s) {
                if (!dp[i][s]) {
                    continue;
                }
                for (int j = i + 1; j < n; ++j) {
                    if (a[j] == 2) {
                        dec(dp[j][s + func(j - i - 1)], dp[i][s]);
                    } else if (a[j] == 1) {
                        inc(dp[j][s + func(j - i - 1)], dp[i][s]);
                        break;
                    }
                }
            }
        }
        int ans = 0;
        for (int s = 1; s < max_s; ++s) {
            inc(ans, mul(dp[n - 1][s], power(s, m)));
        }
        cout << ans << "\n";
    }
    return 0;
}