#include <bits/stdc++.h>
using namespace std;
namespace mine {
long long qread() {
  long long ans = 0, f = 1;
  char c = getchar();
  while (c < '0' or c > '9') {
    if (c == '-') f = -1;
    c = getchar();
  }
  while ('0' <= c and c <= '9') ans = ans * 10 + c - '0', c = getchar();
  return ans * f;
}
void write(long long num) {
  if (num < 0) putchar('-'), num = -num;
  if (num >= 10) write(num / 10);
  putchar('0' + num % 10);
}
void write1(long long num) {
  write(num);
  putchar(' ');
}
void write2(long long num) {
  write(num);
  putchar('\n');
}
template <typename T>
inline bool chmax(T &a, const T &b) {
  return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool chmin(T &a, const T &b) {
  return a > b ? a = b, 1 : 0;
}
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
bool IN(long long x, long long l, long long r) { return l <= x and x <= r; }
void GG() {
  puts("-1");
  exit(0);
}
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const int MOD = 998244353;
int mm(const int x) { return x >= MOD ? x - MOD : x; }
template <typename T>
void add(T &x, const int &y) {
  x = (x + y >= MOD ? x + y - MOD : x + y);
}
long long qpower(long long x, long long e, int mod = MOD) {
  long long ans = 1;
  while (e) {
    if (e & 1) ans = ans * x % mod;
    x = x * x % mod;
    e >>= 1;
  }
  return ans;
}
long long invm(long long x) { return qpower(x, MOD - 2); }
const int MM = 1e6 + 10;
long long fac[MM], facinv[MM], Inv[MM];
long long Comb(int n, int m) {
  return n < 0 or n < m ? 0 : fac[n] * facinv[m] % MOD * facinv[n - m] % MOD;
}
void PRE() {
  fac[0] = 1;
  for (int i = (1), I = (MM - 1); i <= I; i++) fac[i] = fac[i - 1] * i % MOD;
  facinv[MM - 1] = invm(fac[MM - 1]);
  for (int i = (MM - 1), I = (1); i >= I; i--)
    facinv[i - 1] = facinv[i] * i % MOD;
  Inv[1] = 1;
  for (int i = (2), I = (MM - 1); i <= I; i++)
    Inv[i] = (MOD - MOD / i) * Inv[MOD % i] % MOD;
}
const int N = 2e3 + 10;
struct BIT {
  int bit[N];
  void clear() { memset(bit, 0, sizeof bit); }
  int lowbit(int x) { return x & -x; }
  void ch(int x, int c) {
    while (x < N) bit[x] += c, x += lowbit(x);
  }
  int ask(int x) {
    int ret = 0;
    while (x >= 1) ret += bit[x], x -= lowbit(x);
    return ret;
  }
} bit[2];
int a[N][N];
long long D[N], g[N][N];
bool use[N], use2[N];
void main() {
  D[0] = 1, D[1] = 0;
  for (int i = (2), I = (N - 1); i <= I; i++)
    D[i] = (i - 1) * (D[i - 1] + D[i - 2]) % MOD;
  g[0][0] = 1;
  for (int i = (1), I = (N - 1); i <= I; i++) {
    g[i][0] = fac[i];
    for (int j = (1), I = (i); j <= I; j++)
      g[i][j] = mm(g[i][j - 1] + MOD - g[i - 1][j - 1]);
  }
  int n = qread();
  for (int i = (1), I = (n); i <= I; i++)
    for (int j = (1), I = (n); j <= I; j++) a[i][j] = qread();
  int ans = 0;
  for (int i = (1), I = (n); i <= I; i++) {
    int sum = 0;
    memset(use, 0, sizeof use), memset(use2, 0, sizeof use2);
    int lef = n;
    bit[0].clear(), bit[1].clear();
    for (int i = (1), I = (n); i <= I; i++) bit[0].ch(i, 1);
    for (int j = (1), I = (n); j <= I; j++) {
      if (i == 1)
        add(sum, (bit[0].ask(a[i][j] - 1) + bit[1].ask(a[i][j] - 1)) *
                     fac[n - j] % MOD);
      else {
        if (!use[a[i - 1][j]])
          use[a[i - 1][j]] = 1, lef--, bit[0].ch(a[i - 1][j], -1),
                    bit[1].ch(a[i - 1][j], 1);
        int x = bit[0].ask(a[i][j] - 1), y = bit[1].ask(a[i][j] - 1);
        if (a[i - 1][j] < a[i][j] and !use2[a[i - 1][j]])
          (use[a[i - 1][j]] ? y-- : x--);
        add(sum, g[n - j][lef] * y % MOD);
        if (lef) add(sum, g[n - j][lef - 1] * x % MOD);
      }
      use2[a[i][j]] = 1;
      bit[use[a[i][j]]].ch(a[i][j], -1);
      if (!use[a[i][j]]) use[a[i][j]] = 1, lef--;
    }
    add(ans, sum * qpower(D[n], n - i) % MOD);
  }
  write(ans);
}
};  // namespace mine
signed main() {
  srand(time(0));
  mine::PRE();
  mine::main();
  printf("");
}

### Prompt

Develop a solution in Cpp to the problem described below:

Petya collects beautiful matrix.

A matrix of size n × n is beautiful if: 

  * All elements of the matrix are integers between 1 and n; 
  * For every row of the matrix, all elements of this row are different; 
  * For every pair of vertically adjacent elements, these elements are different. 



Today Petya bought a beautiful matrix a of size n × n, and now he wants to determine its rarity.

The rarity of the matrix is its index in the list of beautiful matrices of size n × n, sorted in lexicographical order. Matrix comparison is done row by row. (The index of lexicographically smallest matrix is zero).

Since the number of beautiful matrices may be huge, Petya wants you to calculate the rarity of the matrix a modulo 998 244 353.

Input

The first line contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns in a.

Each of the next n lines contains n integers a_{i,j} (1 ≤ a_{i,j} ≤ n) — the elements of a.

It is guaranteed that a is a beautiful matrix.

Output

Print one integer — the rarity of matrix a, taken modulo 998 244 353.

Examples

Input


2
2 1
1 2


Output


1


Input


3
1 2 3
2 3 1
3 1 2


Output


1


Input


3
1 2 3
3 1 2
2 3 1


Output


3

Note

There are only 2 beautiful matrices of size 2 × 2:

<image>

There are the first 5 beautiful matrices of size 3 × 3 in lexicographical order:

<image>

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
namespace mine {
long long qread() {
  long long ans = 0, f = 1;
  char c = getchar();
  while (c < '0' or c > '9') {
    if (c == '-') f = -1;
    c = getchar();
  }
  while ('0' <= c and c <= '9') ans = ans * 10 + c - '0', c = getchar();
  return ans * f;
}
void write(long long num) {
  if (num < 0) putchar('-'), num = -num;
  if (num >= 10) write(num / 10);
  putchar('0' + num % 10);
}
void write1(long long num) {
  write(num);
  putchar(' ');
}
void write2(long long num) {
  write(num);
  putchar('\n');
}
template <typename T>
inline bool chmax(T &a, const T &b) {
  return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool chmin(T &a, const T &b) {
  return a > b ? a = b, 1 : 0;
}
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
bool IN(long long x, long long l, long long r) { return l <= x and x <= r; }
void GG() {
  puts("-1");
  exit(0);
}
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const int MOD = 998244353;
int mm(const int x) { return x >= MOD ? x - MOD : x; }
template <typename T>
void add(T &x, const int &y) {
  x = (x + y >= MOD ? x + y - MOD : x + y);
}
long long qpower(long long x, long long e, int mod = MOD) {
  long long ans = 1;
  while (e) {
    if (e & 1) ans = ans * x % mod;
    x = x * x % mod;
    e >>= 1;
  }
  return ans;
}
long long invm(long long x) { return qpower(x, MOD - 2); }
const int MM = 1e6 + 10;
long long fac[MM], facinv[MM], Inv[MM];
long long Comb(int n, int m) {
  return n < 0 or n < m ? 0 : fac[n] * facinv[m] % MOD * facinv[n - m] % MOD;
}
void PRE() {
  fac[0] = 1;
  for (int i = (1), I = (MM - 1); i <= I; i++) fac[i] = fac[i - 1] * i % MOD;
  facinv[MM - 1] = invm(fac[MM - 1]);
  for (int i = (MM - 1), I = (1); i >= I; i--)
    facinv[i - 1] = facinv[i] * i % MOD;
  Inv[1] = 1;
  for (int i = (2), I = (MM - 1); i <= I; i++)
    Inv[i] = (MOD - MOD / i) * Inv[MOD % i] % MOD;
}
const int N = 2e3 + 10;
struct BIT {
  int bit[N];
  void clear() { memset(bit, 0, sizeof bit); }
  int lowbit(int x) { return x & -x; }
  void ch(int x, int c) {
    while (x < N) bit[x] += c, x += lowbit(x);
  }
  int ask(int x) {
    int ret = 0;
    while (x >= 1) ret += bit[x], x -= lowbit(x);
    return ret;
  }
} bit[2];
int a[N][N];
long long D[N], g[N][N];
bool use[N], use2[N];
void main() {
  D[0] = 1, D[1] = 0;
  for (int i = (2), I = (N - 1); i <= I; i++)
    D[i] = (i - 1) * (D[i - 1] + D[i - 2]) % MOD;
  g[0][0] = 1;
  for (int i = (1), I = (N - 1); i <= I; i++) {
    g[i][0] = fac[i];
    for (int j = (1), I = (i); j <= I; j++)
      g[i][j] = mm(g[i][j - 1] + MOD - g[i - 1][j - 1]);
  }
  int n = qread();
  for (int i = (1), I = (n); i <= I; i++)
    for (int j = (1), I = (n); j <= I; j++) a[i][j] = qread();
  int ans = 0;
  for (int i = (1), I = (n); i <= I; i++) {
    int sum = 0;
    memset(use, 0, sizeof use), memset(use2, 0, sizeof use2);
    int lef = n;
    bit[0].clear(), bit[1].clear();
    for (int i = (1), I = (n); i <= I; i++) bit[0].ch(i, 1);
    for (int j = (1), I = (n); j <= I; j++) {
      if (i == 1)
        add(sum, (bit[0].ask(a[i][j] - 1) + bit[1].ask(a[i][j] - 1)) *
                     fac[n - j] % MOD);
      else {
        if (!use[a[i - 1][j]])
          use[a[i - 1][j]] = 1, lef--, bit[0].ch(a[i - 1][j], -1),
                    bit[1].ch(a[i - 1][j], 1);
        int x = bit[0].ask(a[i][j] - 1), y = bit[1].ask(a[i][j] - 1);
        if (a[i - 1][j] < a[i][j] and !use2[a[i - 1][j]])
          (use[a[i - 1][j]] ? y-- : x--);
        add(sum, g[n - j][lef] * y % MOD);
        if (lef) add(sum, g[n - j][lef - 1] * x % MOD);
      }
      use2[a[i][j]] = 1;
      bit[use[a[i][j]]].ch(a[i][j], -1);
      if (!use[a[i][j]]) use[a[i][j]] = 1, lef--;
    }
    add(ans, sum * qpower(D[n], n - i) % MOD);
  }
  write(ans);
}
};  // namespace mine
signed main() {
  srand(time(0));
  mine::PRE();
  mine::main();
  printf("");
}

```