#include<bits/stdc++.h>
#define endl '\n'
#define int long long
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define rep2(i,a,b) for(int i=(a);i>=(b);i--)
using namespace std;
template<typename... Args>
void bubu(Args... args) { cout << ":: "; ((cout << args << " "), ...); cout << endl; }
void bubu(vector<int> tem) { for (auto x : tem) cout << x << ' '; cout << endl; }
void kuaidu() { ios::sync_with_stdio(false), cin.tie(0), cout.tie(0); }
inline int max(int a, int b) { if (a < b) return b; return a; }
inline int min(int a, int b) { if (a < b) return a; return b; }
using PII = pair<int, int>;
using i128 = __int128;
struct DSU {
    struct Info {
        int fa;
        int siz;
        vector<int> A;
    };
    vector<Info> dsu;
    Info& operator[](int x) { return dsu[find(x)]; }
    DSU(int n_) { init(n_); }
    void init(int n) {
        dsu.resize(n + 100);
        //TO DO 记得初始化
        rep(i, 1, n) {
            dsu[i].fa = i, dsu[i].siz = 1;
            dsu[i].A.clear();
            dsu[i].A.push_back(i);
        }
    }
    int find(int x) { if (x == dsu[x].fa) return x; return dsu[x].fa = find(dsu[x].fa); }
    void merge(int x, int y) {
        x = find(x), y = find(y);
        if (x == y) return; if (dsu[x].siz < dsu[y].siz) swap(x, y);
        dsu[y].fa = x, dsu[x].siz += dsu[y].siz;
        for (auto y1 : dsu[y].A) {
            dsu[x].A.push_back(y1);
        }
        dsu[y].A.clear();
        dsu[y].siz = 0;
    }
    bool same(int x, int y) {
        x = find(x), y = find(y);
        if (x == y) return 1; return 0;
    }
    int size(int x) { return dsu[find(x)].siz; }
};
//=======================================================================
const int N = 1e6 + 10;
const int M = 1e6 + 10;
const int mod = 1e9 + 7;
const int INF = 1e16;
int n, m, T;
int in[N];
string s[N];
vector<int> A[N], B[N];
bool vis[N];
//=======================================================================
int kuai(int a, int b) {
    int l = 1;
    while (b) {
        if (b % 2) l = l * a % mod;
        a = a * a % mod; b /= 2;
    }
    return l;
}

int dfs1(int x) {
    for (auto y : A[x]) {
        if (vis[y]) return 0;
    }
    for (auto y : A[x]) vis[y] = 1;
    return 1;
}
int dfs2(int x) {
    for (auto y : B[x]) {
        if (vis[y]) return 0;
    }
    for (auto y : B[x]) vis[y] = 1;
    return 1;
}

int co[N];
bool dnf[N];
bool dfs(int x, vector<int>(&A)[]) {

    int las, fl = 1;
    for (auto y : A[x]) {
        if (co[y]) { fl = 0; las = co[y]; break; }
    }
    if (las == x) { return 0; }
    if (fl || dfs(las, B)) {
        for (auto y : A[x]) {
            co[y] = x;
        }
        return 1;
    }
    return 0;
}

signed main() {
    kuaidu();
    cin >> T;
    while (T--) {
        cin >> n >> m;
        rep(i, 1, n + m) {
            in[i] = 0, vis[i] = 0; co[i] = 0;
            A[i].clear();
            B[i].clear();
        }
        DSU dsu(n + m + 100);

        rep(i, 1, n) {
            cin >> s[i];
            rep(j, 0, m - 1) {
                if (s[i][j] == '1') {
                    in[j + 1]++;
                    in[m - j]++;
                }
            }
        }

        int flag = 1;
        rep(i, 1, m + n) {
            if (in[i] >= 3) {
                cout << 0 << endl;
                flag = 0;
                break;
            }
        }
        if (flag == 0) continue;

        rep(i, 1, n) {
            rep(j, 0, m - 1) {
                if (s[i][j] == '1') {
                    dsu.merge(i, j + 1 + n);
                    dsu.merge(i, m - j + n);
                    A[i].push_back(j + 1);
                    B[i].push_back(m - j);
                }
            }
        }

        rep(i, 1, n) {
            if (i != dsu.find(i)) continue;
            for (auto x : dsu[i].A) {
                if (x > n) continue;
                if (dfs(x, A)) continue;
                if (dfs(x, B)) continue;
                flag = 0;
                goto Z;
            }
        }
    Z:;
        if (flag == 0) {
            cout << 0 << endl;
            continue;
        }
        set<int> S; S.clear();
        rep(i, 1, n) {
            S.insert(dsu.find(i));
        }
        int ans = kuai(2, S.size());
        cout << ans << endl;
    }
    return 0;
}