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

using i64 = long long;
const int mod = 1e9 + 7;

struct TwoSat {
    int n;
    vector<vector<int>> e;
    vector<bool> ans;

    TwoSat(int n) : n(n), e(2 * n), ans(n) {}

    // u为true，或者v为true
    //     u(false)->v(true)
    //     v(false)->u(true)
    void addedge(int u, bool a, int v, bool b) {
        e[2 * u + !a].push_back(2 * v + b);
        e[2 * v + !b].push_back(2 * u + a);

        e[2 * v + b].push_back(2 * u + !a);
        e[2 * u + a].push_back(2 * v + !b);
    }

    bool satisfible() {
        int dfncnt = 0, cnt = 0;
        vector<int> dfn(2 * n), low(2 * n), id(2 * n);
        stack<int> stk;
        auto tarjan = [&](auto self, int u) -> void {
            stk.push(u);
            dfn[u] = low[u] = ++dfncnt;
            for (auto v : e[u]) {
                if (dfn[v] == 0) {
                    self(self, v);
                    low[u] = min(low[u], low[v]);
                } else if (id[v] == 0) {
                    low[u] = min(low[u], dfn[v]);
                }
            }
            if (dfn[u] == low[u]) {
                ++cnt;
                int v;
                do {
                    v = stk.top();
                    stk.pop();
                    id[v] = cnt;
                } while (v != u);
            }
        };
        for (int i = 0; i < 2 * n; i++) {
            if (dfn[i] == 0) {
                tarjan(tarjan, i);
            }
        }
        for (int i = 0; i < n; i++) {
            if (id[2 * i] == id[2 * i | 1]) {
                return false;
            }
            ans[i] = id[2 * i] > id[2 * i | 1];
        }
        return true;
    }

    vector<bool> answer() {
        return ans;
    }
};

struct DSU {
    vector<int> f, siz;

    DSU() {}
    DSU(int n) {
        init(n);
    }

    void init(int n) {
        f.resize(n);
        iota(f.begin(), f.end(), 0);
        siz.assign(n, 1);
    }

    int find(int x) {
        while (f[x] != x) {
            x = f[x] = f[f[x]];
        }
        return x;
    }

    bool merge(int x, int y) {
        x = find(x);
        y = find(y);
        if (x == y) {
            return false;
        }
        siz[x] += siz[y];
        f[y] = x;
        return true;
    }

    int size(int x) {
        return siz[find(x)];
    }

    bool same(int x, int y) {
        return find(x) == find(y);
    }
};

void solve() {
    int n, m, cal = 0;
    cin >> n >> m;

    vector<vector<int>> pos(m + 1);
    vector<vector<int>> a(n + 1, vector<int>(m + 1));
    for (int i = 1; i <= n; i++) {
        string s;
        cin >> s;

        for (int j = 1; j <= m; j++) {
            a[i][j] = (s[j - 1] == '1');
            if (a[i][j] == 1) {
                pos[j].push_back(i);
                cal++;
            }
        }
    }

    if (cal > m) {
        cout << 0 << "\n";
        return;
    }

    int ok = 1;

    TwoSat ts(n);
    for (int i = 1; i <= m / 2; i++) {
        int j = m - i + 1;
        if (pos[i].size() + pos[j].size() > 2) {
            ok = 0;
            break;
        }

        for (int ii = 0; ii < pos[i].size(); ii++) {
            for (int jj = ii + 1; jj < pos[i].size(); jj++) {
                ts.addedge(pos[i][ii] - 1, 1, pos[i][jj] - 1, 1);
            }
        }

        for (int ii = 0; ii < pos[j].size(); ii++) {
            for (int jj = ii + 1; jj < pos[j].size(); jj++) {
                ts.addedge(pos[j][ii] - 1, 1, pos[j][jj] - 1, 1);
            }
        }

        for (int ii = 0; ii < pos[i].size(); ii++) {
            for (int jj = 0; jj < pos[j].size(); jj++) {
                ts.addedge(pos[i][ii] - 1, 1, pos[j][jj] - 1, 0);
            }
        }
    }

    if (m % 2 == 1 && pos[m / 2 + 1].size() > 1) {
        ok = 0;
    }

    if (!ok) {
        cout << 0 << endl;
        return;
    }

    DSU dsu(n);
    for (int i = 1; i <= m / 2; i++) {
        int j = m - i + 1;

        for (int ii = 0; ii < pos[i].size(); ii++) {
            dsu.merge(pos[i][0] - 1, pos[i][ii] - 1);
        }

        for (int ii = 0; ii < pos[j].size(); ii++) {
            dsu.merge(pos[j][0] - 1, pos[j][ii] - 1);
        }

        if (pos[i].size() > 0 && pos[j].size() > 0) {
            dsu.merge(pos[i][0] - 1, pos[j][0] - 1);
        }
    }

    int ans = 1;
    for (int i = 0; i < n; i++) {
        if (dsu.find(i) == i) {
            ans = (ans * 2) % mod;
        }
    }
    cout << ans << endl;
}

int main(void)
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t;
    cin >> t;

    while (t--) {
        solve();
    }

    return 0;
}