#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <stack>
#include <tuple>

using namespace std;

#ifdef LOCAL
template <class T, size_t size = tuple_size<T>::value>
string to_debug(T, string s = "")
    requires(not ranges::range<T>);
string to_debug(auto x)
    requires requires(ostream &os) { os << x; }
{
    return static_cast<ostringstream>(ostringstream() << x).str();
}
string to_debug(ranges::range auto x, string s = "")
    requires(not is_same_v<decltype(x), string>)
{
    for (auto &xi : x)
    {
        s += ", " + to_debug(xi);
    }
    return "[" + s.substr(s.empty() ? 0 : 2) + "]";
}
template <class T, size_t size>
string to_debug(T x, string s)
    requires(not ranges::range<T>)
{
    [&]<size_t... I>(index_sequence<I...>)
    {
        ((s += ", " + to_debug(get<I>(x))), ...);
    }(make_index_sequence<size>());
    return "(" + s.substr(s.empty() ? 0 : 2) + ")";
}
#define debug(...) cerr << __LINE__ << ": (" #__VA_ARGS__ ") = " << to_debug(tuple(__VA_ARGS__)) << "\n"
#else
#define debug(X...)
#endif

using i64 = long long;

#define int long long

const int mod = 1e9 + 7;

const int mxn = 1e6 + 6;

i64 fastpow(i64 dx, int dp)
{
    i64 res = 1;
    while (dp)
    {
        if (dp & 1)
            res = (res * dx) % mod;
        dx = (dx * dx) % mod;
        dp >>= 1;
    }
    return res;
}

struct DSU {
    std::vector<int> f, siz;
    
    DSU() {}
    DSU(int n) {
        init(n);
    }
    
    void init(int n) {
        f.resize(n);
        std::iota(f.begin(), f.end(), 0);
        siz.assign(n, 1);
    }
    
    int find(int x) {
        while (x != f[x]) {
            x = f[x] = f[f[x]];
        }
        return x;
    }
    
    bool same(int x, int y) {
        return find(x) == find(y);
    }
    
    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)];
    }
};

void solve()
{
#define tests
    int n, m; cin >> n >> m;
    vector<string> a(n); for (auto &ai : a) {cin >> ai;}

    DSU dsu(n * 2);

    // judge no sol
    for (int l = 0, r = m - 1; l <= r; l++, r--)
    {
        std::vector<int> pos;
        bool has_l{}, has_r{};
        for (int i = 0; i < n; i++) {
            if (a[i][l] == '1') {has_l = true; pos.push_back(i);}
            if (l != r and a[i][r] == '1') {has_r = true; pos.push_back(i);}
        }
        if (l == r) {
            if (pos.size() >= 2) {cout << "0\n"; return ;}
        } else {
            if (pos.size() >= 3) {cout << "0\n"; return ;}
            if (pos.size() == 2 and pos[0] != pos[1]) {//只有不一样才能旋转
                if (has_l and has_r) {//同一列，只能操作相异
                    dsu.merge(pos[0], pos[1] + n);
                    dsu.merge(pos[0] + n, pos[1]);
                } else {//否则只能操作相同
                    dsu.merge(pos[0], pos[1]);
                    dsu.merge(pos[0] + n, pos[1] + n);
                }
            }
        }
    }

    //如果自环就无解
    for (int i = 0; i < n; i++) if (dsu.same(i, i + n)) {cout << "0\n"; return ;}

    int p{}; for (int i = 0; i < n * 2; i++) if (i == dsu.find(i)) {p += 1;} p /= 2;

    cout << fastpow(2, p) << "\n";
}

signed main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    int _{1};
#ifdef tests
    cin >> _;
#endif
    while (_--)
    {
        solve();
    }
    return 0;
}