#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;

int fa[mxn];

int fd(int nx)
{
    return nx == fa[nx] ? nx : fa[nx] = fd(fa[nx]);
}

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;
}

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

    for (int i = 0; i < n; i++)
        fa[i] = i;

    // judge no sol
    vector<int> cnti;
    bool no_sol = false;
    for (int fmn, fmx, f1, f2, l = 0, r = m - 1; l <= r; l++, r--)
    {
        cnti.clear();
        for (int i = 0; i < n; i++)
        {
            if (a[i][l] == '1')
                cnti.push_back(i);
            if (l != r && a[i][r] == '1')
                cnti.push_back(i);
        }
        if (l == r)
        {
            if (cnti.size() >= 2)
            {
                no_sol = true;
                break;
            }
        }
        else
        {
            if (cnti.size() >= 3)
            {
                no_sol = true;
                break;
            }
            if (cnti.size() == 2 && cnti[0] != cnti[1])
            {
                f1 = fd(cnti[0]);
                f2 = fd(cnti[1]);
                if (f1 != f2)
                {
                    //fa[f2] = f1;
                    fmn = min(f2, f1);
                    fmx = max(f2, f1);
                    fa[fmx] = fmn;
                }
            }
        }
    }
    if (no_sol)
    {
        cout << "0\n";
        return;
    }
    else
    {
        int p = 0;
        for (int fi, i = 0; i < n; i++)
        {
            fi = fd(i);
            if (fi == i)
            {
                p++;
            }
        }
        cout << fastpow(2, p) << "\n";
    }
}

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