#include <bits/stdc++.h>
using namespace std;
// https://space.bilibili.com/672346917

#ifndef LOCAL
#define LOG(...) 42
#endif

#define fi first
#define se second
#define pb push_back
#define endl '\n'
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()

typedef long long LL;
typedef pair <int, int> PII;

constexpr int inf = 0x3f3f3f3f;
constexpr double EPS = 1e-8;
const double PI = acos(-1);

int multi_cases = 1;

constexpr int P = 1000000007;
// constexpr int P = 998244353;

// assume -p <= x < 2P
int norm(int x) {
    if (x < 0) { x += P; }
    if (x >= P) { x -= P; }
    return x;
}
template<class T>
T power(T a, int b) {
    T res = 1;
    for (; b; b >>= 1, a *= a)  if (b & 1) res *= a;
    return res;
}
struct Z {
    int x;
    Z(int x = 0) : x(norm(x)) {}
    int val() const { return x; }
    Z operator-() const { return Z(norm(P - x)); }
    Z inv() const { assert(x != 0); return power(*this, P - 2); }
    Z &operator*=(const Z &rhs) { x = (long long)(x) * rhs.x % P; return *this; }
    Z &operator+=(const Z &rhs) { x = norm(x + rhs.x); return *this; }
    Z &operator-=(const Z &rhs) { x = norm(x - rhs.x); return *this; }
    Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
    friend Z operator*(const Z &lhs, const Z &rhs) { Z res = lhs; res *= rhs; return res; }
    friend Z operator+(const Z &lhs, const Z &rhs) { Z res = lhs; res += rhs; return res; }
    friend Z operator-(const Z &lhs, const Z &rhs) { Z res = lhs; res -= rhs; return res; }
    friend Z operator/(const Z &lhs, const Z &rhs) { Z res = lhs; res /= rhs; return res; }
    friend bool operator==(const Z &lhs, const Z &rhs) { return lhs.val() == rhs.val(); }
    friend istream &operator >> (istream &input, Z &o) {  input >> o.x; return input; }
    friend ostream &operator << (ostream &output, const Z &o) { output << o.val(); return output; }
};

void A_SOUL_AvA () {
    int n, m;
    cin >> n >> m;

    vector <int> a(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    if (n & 1) {
        cout << 0 << endl;
        return;
    }

    vector f(n + 5, vector<int>(n + 5, -1));

    function <int(int, int)> DFS = [&](int l, int r) -> int {
        if ((r - l + 1) % 2) return 0;
        if (l > r) return 1;
        if (~f[l][r]) return f[l][r];

        Z ans = 0;
        int i = l, j = r;
        for (int k = i + 1; k <= j; k ++) {
            if (a[i] > 0) {
                if (a[k] == 0 || a[k] < 0 && a[k] + a[i] == 0) {
                    ans += Z(1) * DFS(i + 1, k - 1) * DFS(k + 1, j);
                }
            } else if (a[i] == 0) {
                if (a[k] == 0) {
                    ans += Z(1) * DFS(i + 1, k - 1) * m * DFS(k + 1, j);
                } else if (a[k] < 0) {
                    ans += Z(1) * DFS(i + 1, k - 1) * DFS(k + 1, j);
                }
            }
        }
        return f[l][r] = ans.val();
    };

    cout << DFS(1, n) << endl;
}

int main () {
    cin.tie(nullptr)->sync_with_stdio(false);
    cout << fixed << setprecision(12);

    int T = 1;
    for (multi_cases && cin >> T; T; T--) {
        A_SOUL_AvA ();
    }

    return 0;
}