#include <bits/stdc++.h>

#define long long long int
#define DEBUG
using namespace std;

// @author: pashka

const int mod = 998244353;

struct mint {
    int value = 0;

    constexpr mint() : value() {}

    mint(const long &x) {
        value = normalize(x);
    }

    static long normalize(const long &x) {
        long v = x % mod;
        if (v < 0) v += mod;
        return v;
    }

    bool operator==(const mint &x) { return value == x.value; };

    mint operator+(const mint &x) { return value + x.value; };

    mint operator-(const mint &x) { return value - x.value; };

    mint operator*(const mint &x) { return (long) value * x.value; };

    void operator+=(const mint &x) { value = normalize(value + x.value); };

    void operator-=(const mint &x) { value = normalize(value - x.value); };
};


struct test {

    vector<vector<mint>> precalc(vector<string> a, bool fv, bool fh, char N, char W) {
        int n = a.size();
        int m = a[0].size();
        if (fv) reverse(a.begin(), a.end());
        if (fh) {
            for (auto &aa: a) reverse(aa.begin(), aa.end());
        }
        vector<int> h(n);
        for (int i = 0; i < n; i++) {
            while (h[i] < m && (a[i][h[i]] == '?' || a[i][h[i]] == W)) h[i]++;
        }
        vector<int> v(m);
        for (int i = 0; i < m; i++) {
            while (v[i] < n && (a[v[i]][i] == '?' || a[v[i]][i] == N)) v[i]++;
        }

        vector<vector<mint>> d(n + 1, vector<mint>(m + 1));
        d[0][0] = 1;
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= m; j++) {
                if (i + 1 <= n && h[i] >= j) {
                    d[i + 1][j] += d[i][j];
                }
                if (j + 1 <= m && v[j] >= i) {
                    d[i][j + 1] += d[i][j];
                }
            }
        }

        if (fv) reverse(d.begin(), d.end());
        if (fh) {
            for (auto &aa: d) reverse(aa.begin(), aa.end());
        }

//        cout << N << " " << W << "\n";
//        for (int i = 0; i <= n; i++) {
//            for (int j = 0; j <= m; j++) {
//                cout << d[i][j].value << " ";
//            }
//            cout << "\n";
//        }

        return d;
    }

    vector<vector<bool>> precalcv(vector<string> a, bool f) {
        if (f) reverse(a.begin(), a.end());
        int n = a.size();
        int m = a[0].size();
        vector<vector<bool>> d(n + 1, vector<bool>(m, true));
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                d[i + 1][j] = (a[i][j] == "NS"[f] || a[i][j] == '?') ? d[i][j] : false;
            }
        }
        if (f) reverse(d.begin(), d.end());
        return d;
    }

    vector<vector<bool>> precalch(vector<string> a, bool f) {
        if (f) for (auto &aa: a) reverse(aa.begin(), aa.end());
        int n = a.size();
        int m = a[0].size();
        vector<vector<bool>> d(n, vector<bool>(m + 1, true));
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                d[i][j + 1] = (a[i][j] == "WE"[f] || a[i][j] == '?') ? d[i][j] : false;
            }
        }
        if (f) for (auto &aa: d) reverse(aa.begin(), aa.end());
        return d;
    }


    mint solve(vector<string> a) {
        auto dnw = precalc(a, false, false, 'N', 'W');
        auto dne = precalc(a, false, true, 'N', 'E');
        auto dsw = precalc(a, true, false, 'S', 'W');
        auto dse = precalc(a, true, true, 'S', 'E');

        auto dn = precalcv(a, false);
        auto ds = precalcv(a, true);
        auto dw = precalch(a, false);
        auto de = precalch(a, true);

        int n = a.size();
        int m = a[0].size();

        vector<int> v(m);
        for (int i = 0; i < m; i++) {
            while (v[i] < n && (a[v[i]][i] == '?' || a[v[i]][i] == 'N')) v[i]++;
        }

        vector<mint> dl(m + 1);
        {
            dl[0] = 1;
            vector<bool> ok(n, true);
            for (int j = 0; j < m; j++) {
                for (int i = 0; i < n; i++) {
                    if (a[i][j] != '?' && a[i][j] != 'W') ok[i] = false;
                }
                for (int i = 0; i < n; i++) {
                    if (!ok[i] || v[j] < i) continue;
                    dl[j + 1] += dnw[i][j] * dsw[i + 1][j + 1];
                }
            }
        }
        vector<mint> dr(m + 1);
        {
            dr[m] = 1;
            vector<bool> ok(n, true);
            for (int j = m - 1; j >= 0; j--) {
                for (int i = 0; i < n; i++) {
                    if (a[i][j] != '?' && a[i][j] != 'E') ok[i] = false;
                }
                for (int i = 0; i < n; i++) {
                    if (!ok[i] || v[j] < i) continue;
                    dr[j] += dne[i][j + 1] * dse[i + 1][j];
                }
            }
        }
        vector<mint> dv(m);
        for (int j = 0; j < m; j++) {
            int mxn = -1;
            int mns = n;
            bool ok = true;
            for (int i = 0; i < n; i++) {
                if (a[i][j] == 'N') {
                    mxn = max(mxn, i);
                } else if (a[i][j] == 'S') {
                    mns = min(mns, i);
                } else if (a[i][j] != '?') {
                    ok = false;
                }
            }
            if (ok && mns > mxn) {
                dv[j] = mns - mxn;
            }
        }
        mint res = 0;
        for (int l = 0; l < m; l++) {
            mint s = 1;
            for (int r = l; r < m; r++) {
                s = s * dv[r];
                res += s * dl[l] * dr[r + 1];
            }
        }
        vector<mint> q(n);
        for (int j = 0; j < m - 1; j++) {
            for (int i = 0; i < n; i++) {
                if (dw[i][j + 1] && dn[i][j]) {
                    q[i] = dnw[i][j] * dsw[i + 1][j + 1];
                } else {
                    q[i] = 0;
                }
            }
            for (int i = n - 2; i >= 0; i--) q[i] += q[i + 1];
            for (int i = 0; i < n - 2; i++) {
                if (de[i][j] && ds[i + 1][j]) {
                    res += dne[i][j + 1] * dse[i + 1][j + 2] *
                           q[i + 2];
                }
            }
        }
        for (int j = 0; j < m - 1; j++) {
            for (int i = 0; i < n; i++) {
                if (dw[i][j + 1] && ds[i + 1][j]) {
                    q[i] = dnw[i][j + 1] * dsw[i + 1][j];
                } else {
                    q[i] = 0;
                }
            }
            for (int i = 1; i < n; i++) q[i] += q[i - 1];
            for (int i = 2; i < n; i++) {
                if (de[i][j] && dn[i][j]) {
                    res += dne[i][j + 2] * dse[i + 1][j + 1] *
                           q[i - 2];
                }
            }
        }

        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < m - 1; j++) {
                if (dn[i + 1][j] && ds[i + 1][j + 1] &&
                    dw[i + 1][j + 1] && de[i][j + 1]) {
                    res += dnw[i + 1][j] * dne[i][j + 1] * dsw[i + 2][j + 1] * dse[i + 1][j + 2];
                }
            }
        }
        return res;
    }

    void solve() {
        int n, m;
        cin >> n >> m;
        vector<string> a(n);
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }
        vector<string> aa(m);
        string S = "NWSE??";
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                aa[j] += S[S.find(a[i][j]) ^ 1];
            }
        }
        auto res = solve(a) + solve(aa);
        cout << res.value << "\n";
    }
};

int main() {
    ios::sync_with_stdio(false);

    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        test().solve();
    }

    return 0;
}