package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"os"
)

const MOD = 1000000007

func modInverse(a uint64) uint64 {
	return power(a, MOD-2)
}

func power(base, exp uint64) uint64 {
	res := uint64(1)
	base %= MOD
	for exp > 0 {
		if exp%2 == 1 {
			res = (res * base) % MOD
		}
		base = (base * base) % MOD
		exp /= 2
	}
	return res
}

type State struct {
	d [7]uint64
}

func pack(fk []byte) State {
	var s State
	for i, v := range fk {
		s.d[i/21] |= uint64(v) << (3 * (i % 21))
	}
	return s
}

func unpack(s State, fk []byte) {
	for i := range fk {
		fk[i] = byte((s.d[i/21] >> (3 * (i % 21))) & 7)
	}
}

type Pair struct {
	j    int
	idxS int
}

type Transition struct {
	idxS  int
	pairs []Pair
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	if _, err := fmt.Fscan(reader, &n); err != nil {
		return
	}

	P := make([][]int, n)
	for i := 0; i < n; i++ {
		P[i] = make([]int, n)
		for j := 0; j < n; j++ {
			fmt.Fscan(reader, &P[i][j])
		}
	}

	inv100 := modInverse(100)
	probE := make([][]uint64, n)
	for k := 0; k < n; k++ {
		probE[k] = make([]uint64, 1<<n)
		for E := 0; E < (1<<n); E++ {
			p := uint64(1)
			for j := 0; j < n; j++ {
				edgeProb := (uint64(P[k][j]) * inv100) % MOD
				if (E&(1<<j)) != 0 {
					p = (p * edgeProb) % MOD
				} else {
					p = (p * (1 - edgeProb + MOD)) % MOD
				}
			}
			probE[k][E] = p
		}
	}

	subsets := make([][]int, n+1)
	for k := 0; k <= n; k++ {
		for S := 0; S < (1<<n); S++ {
			if bits.OnesCount(uint(S)) >= k {
				subsets[k] = append(subsets[k], S)
			}
		}
	}

	idx := make([]map[int]int, n+1)
	for k := 0; k <= n; k++ {
		idx[k] = make(map[int]int)
		for i, S := range subsets[k] {
			idx[k][S] = i
		}
	}

	trans := make([][]Transition, n)
	for k := 0; k < n; k++ {
		trans[k] = make([]Transition, len(subsets[k+1]))
		for i, S := range subsets[k+1] {
			trans[k][i].idxS = idx[k][S]
			for j := 0; j < n; j++ {
				if (S & (1 << j)) != 0 {
					S_minus_j := S ^ (1 << j)
					trans[k][i].pairs = append(trans[k][i].pairs, Pair{
						j:    j,
						idxS: idx[k][S_minus_j],
					})
				}
			}
		}
	}

	dp := make(map[State]uint64)
	initialFk := make([]byte, len(subsets[0]))
	dp[pack(initialFk)] = 1

	fkNextBuf := make([][]byte, 1<<n)
	for E := 0; E < (1<<n); E++ {
		fkNextBuf[E] = make([]byte, 128)
	}
	M_buf := make([][]byte, n)
	for j := 0; j < n; j++ {
		M_buf[j] = make([]byte, 128)
	}
	fk := make([]byte, 128)

	for k := 0; k < n; k++ {
		nextDp := make(map[State]uint64)
		Nk1 := len(subsets[k+1])

		for state, probState := range dp {
			unpack(state, fk[:len(subsets[k])])

			for i := 0; i < Nk1; i++ {
				fkNextBuf[0][i] = fk[trans[k][i].idxS]
				for j := 0; j < n; j++ {
					M_buf[j][i] = 0
				}
				for _, pair := range trans[k][i].pairs {
					M_buf[pair.j][i] = fk[pair.idxS] + 1
				}
			}

			for E := 1; E < (1<<n); E++ {
				j := bits.TrailingZeros32(uint32(E))
				prevE := E ^ (1 << j)
				for i := 0; i < Nk1; i++ {
					val := fkNextBuf[prevE][i]
					if v := M_buf[j][i]; v > val {
						val = v
					}
					fkNextBuf[E][i] = val
				}
			}

			for E := 0; E < (1<<n); E++ {
				probE_val := probE[k][E]
				if probE_val == 0 {
					continue
				}
				nextState := pack(fkNextBuf[E][:Nk1])
				nextDp[nextState] = (nextDp[nextState] + probState*probE_val) % MOD
			}
		}
		dp = nextDp
	}

	ans := uint64(0)
	for state, probState := range dp {
		unpack(state, fk[:1])
		if fk[0] == byte(n) {
			ans = (ans + probState) % MOD
		}
	}

	fmt.Println(ans)
}