#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

const int MOD = 998244353;

int add(int a, int b) {
    return a + b >= MOD ? a + b - MOD : a + b;
}

int sub(int a, int b) {
    return a >= b ? a - b : a + MOD - b;
}

int mul(int a, int b) {
    return (1ll * a * b) % MOD;
}

const int MAXN = 3e3 + 100;
string a[MAXN];
int dp[MAXN][MAXN];
int lft[MAXN], rgh[MAXN];


int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int n;
    cin >> n;

    for (int i = 0; i < n; ++i) {
        cin >> a[i];
        lft[i] = -1; rgh[i] = n;
    }

    dp[0][0] = 1;
    for (int i = 0; i < n; ++i) {
        /// i -> i + 1
        int curl = -1, curr = n;
        int have = 0;
        for (int j = 0; j <= n; ++j) {
            dp[i + 1][j] = mul(dp[i][j], max(0, min(curr, j) - curl));
            if (j != 0 && curr == n) {
                /**if (i == 1 && j == 2) {
                    cerr << "(have: " << have << ")";
                }*/
                dp[i + 1][j] = add(dp[i + 1][j], mul(have, max(0, min(rgh[j - 1], i - 1) - lft[j - 1])));
            }
            if (j >= 1) {
                have = mul(have, max(0, min(rgh[j - 1], i) - lft[j - 1]));
            }
            if (j != n) {
                /// have = mul(have, max(0, min(rgh[j], i) - lft[j]));
                have = add(have, dp[i][j]);
                if (a[i][j] == '0') {
                    curr = min(curr, j);
                } else if (a[i][j] == '1') {
                    curl = max(curl, j);
                }
            }
            /// cerr << dp[i + 1][j] << " ";
        }
        /// cerr << "\n";
        for (int j = 0; j < n; ++j) {
            if (a[i][j] == '0') {
                rgh[j] = min(rgh[j], i);
            } else if (a[i][j] == '1') {
                lft[j] = max(lft[j], i);
            }
        }
    }

    int have = 1;
    for (int j = 0; j < n; ++j) {
        have = add(dp[n][j + 1], mul(have, max(0, rgh[j] - lft[j])));
    }

    cout << have << "\n";

    
    return 0;
}