Problem: This is an easier version of the problem. In this version, n ≤ 6.

Marek is working hard on creating strong testcases to his new algorithmic problem. You want to know what it is? Nah, we're not telling you. However, we can tell you how he generates the testcases.

Marek chooses an integer n and n^2 integers p_{ij} (1 ≤ i ≤ n, 1 ≤ j ≤ n). He then generates a random bipartite graph with 2n vertices. There are n vertices on the left side: ℓ_1, ℓ_2, ..., ℓ_n, and n vertices on the right side: r_1, r_2, ..., r_n. For each i and j, he puts an edge between vertices ℓ_i and r_j with probability p_{ij} percent.

It turns out that the tests will be strong only if a perfect matching exists in the generated graph. What is the probability that this will occur?

It can be shown that this value can be represented as P/Q where P and Q are coprime integers and Q not≡ 0 \pmod{10^9+7}. Let Q^{-1} be an integer for which Q ⋅ Q^{-1} ≡ 1 \pmod{10^9+7}. Print the value of P ⋅ Q^{-1} modulo 10^9+7.

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 6). The following n lines describe the probabilities of each edge appearing in the graph. The i-th of the lines contains n integers p_{i1}, p_{i2}, ..., p_{in} (0 ≤ p_{ij} ≤ 100); p_{ij} denotes the probability, in percent, of an edge appearing between ℓ_i and r_j.

Output

Print a single integer — the probability that the perfect matching exists in the bipartite graph, written as P ⋅ Q^{-1} \pmod{10^9+7} for P, Q defined above.

Examples

Input


2
50 50
50 50


Output


937500007


Input


3
3 1 4
1 5 9
2 6 5


Output


351284554

Note

In the first sample test, each of the 16 graphs below is equally probable. Out of these, 7 have a perfect matching:

<image>

Therefore, the probability is equal to 7/16. As 16 ⋅ 562 500 004 = 1 \pmod{10^9+7}, the answer to the testcase is 7 ⋅ 562 500 004 mod{(10^9+7)} = 937 500 007.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize "-O3"
#pragma GCC optimize("Ofast")
#pragma comment(linker, "/STACK:1000000000")
const int mod = 1e9 + 7;
int sum(int a, int b) {
  int c = a + b;
  if (c >= mod) {
    c -= mod;
  }
  return c;
}
int dif(int a, int b) {
  int c = a - b;
  if (c < 0) {
    c += mod;
  }
  return c;
}
int mlt(int a, int b) {
  long long c = a * 1LL * b;
  return c % mod;
}
int ibit(int n, int i) { return ((n >> i) & 1); }
void outp1(vector<long long> &ou, string s = " ") {
  cerr << s << endl;
  for (int i = 0; i < ou.size(); i++) {
    cerr << ou[i] << ' ';
  }
  cerr << endl;
}
void outp1(vector<int> &ou, string s = " ") {
  cerr << s << endl;
  for (int i = 0; i < ou.size(); i++) {
    cerr << ou[i] << ' ';
  }
  cerr << endl;
}
void outp2(vector<vector<int>> &ou, string s = " ") {
  cerr << s << endl;
  for (int i = 0; i < ou.size(); i++) {
    for (int j = 0; j < ou[i].size(); j++) {
      cerr << ou[i][j] << ' ';
    }
    cerr << '\n';
  }
}
int bp(int x, int y) {
  if (y == 0) {
    return 1;
  }
  int a = 0;
  if (!(y % 2)) {
    a = bp(x, y / 2);
  }
  return (y % 2) ? mlt(bp(x, y - 1), x) : mlt(a, a);
}
int obr(int x) { return bp(x, mod - 2); }
const int maxn = 301;
int fact[maxn], ofact[maxn];
void prec() {
  fact[0] = 1;
  ofact[0] = 1;
  for (int i = 1; i < maxn; i++) {
    fact[i] = mlt(fact[i - 1], i);
  }
  ofact[maxn - 1] = obr(fact[maxn - 1]);
  for (int i = maxn - 2; i > 0; i--) {
    ofact[i] = mlt(ofact[i + 1], i + 1);
  }
}
int c(int a, int b) {
  return ((a <= b) && (a >= 0)) ? mlt(fact[b], mlt(ofact[a], ofact[b - a])) : 0;
}
const int rsto = bp(100, mod - 2);
void recalc(map<vector<int>, int> &dyn, const vector<int> &probs, int t,
            vector<vector<vector<int>>> &trans) {
  vector<int> goodsz;
  map<vector<int>, int> newdyn;
  int n = probs.size();
  for (int mask = 0; mask < (1 << n); mask++) {
    int cnt = 0;
    for (int i = 0; i < n; i++)
      if (ibit(mask, i)) cnt++;
    if (cnt == t) goodsz.push_back(mask);
  }
  for (int mask = 0; mask < (1 << n); mask++) {
    int prb = 1;
    vector<int> added;
    for (int i = 0; i < n; i++) {
      if (ibit(mask, i)) {
        added.push_back(i);
        prb = mlt(prb, probs[i]);
      } else
        prb = mlt(prb, mod + 1 - probs[i]);
    }
    for (auto it = dyn.begin(); it != dyn.end(); it++) {
      vector<int> va = it->first;
      vector<int> used(trans[t + 1].size());
      for (int i = 0; i < va.size(); i++) {
        if (va[i]) {
          for (auto pos : added) {
            if (pos >= (int)trans[t][i].size()) {
              cout << 333 << endl;
              exit(0);
            }
            int val = trans[t][i][pos];
            if (val >= (int)used.size()) {
              cout << 333 << endl;
              exit(0);
            }
            if (val != -1) used[val] = 1;
          }
        }
      }
      if (!newdyn.count(used))
        newdyn[used] = mlt(prb, it->second);
      else
        newdyn[used] = sum(newdyn[used], mlt(prb, it->second));
    }
  }
  dyn = newdyn;
}
vector<vector<int>> enc;
vector<vector<vector<int>>> trans;
void solve(istream &cin = std::cin, ostream &cout = std::cout) {
  int n;
  cin >> n;
  enc.resize(n + 1);
  trans.resize(n + 1);
  vector<vector<int>> v(n, vector<int>(n));
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) cin >> v[i][j];
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) v[i][j] = mlt(v[i][j], rsto);
  for (int mask = 0; mask < (1 << n); mask++) {
    int cnt = 0;
    for (int i = 0; i < n; i++)
      if (ibit(mask, i)) cnt++;
    enc[cnt].push_back(mask);
  }
  for (int i = 0; i <= n; i++) {
    trans[i].resize(enc[i].size());
    for (int pos = 0; pos < enc[i].size(); pos++) {
      int j = enc[i][pos];
      for (int h = 0; h < n; h++) {
        if (ibit(j, h))
          trans[i][pos].push_back(-1);
        else {
          int val = j + (1 << h);
          for (int q = 0; q < enc[i + 1].size(); q++) {
            if (enc[i + 1][q] == val) {
              trans[i][pos].push_back(q);
            }
          }
        }
      }
    }
  }
  map<vector<int>, int> dyn;
  vector<int> q = {1};
  dyn[q] = 1;
  for (int i = 0; i < n; i++) recalc(dyn, v[i], i, trans);
  vector<int> vt = {1};
  cout << dyn[vt] << '\n';
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int tests = 1;
  for (int i = 0; i < tests; i++) {
    solve();
  }
}