```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

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

	if n+m-1 > k {
		fmt.Println(0)
		return
	}

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

	if n < m {
		newGrid := make([][]int, m)
		for i := 0; i < m; i++ {
			newGrid[i] = make([]int, n)
			for j := 0; j < n; j++ {
				newGrid[i][j] = grid[j][i]
			}
		}
		grid = newGrid
		n, m = m, n
	}

	present := make([]bool, k+1)
	for i := 0; i < n; i++ {
		for j := 0; j < m; j++ {
			if grid[i][j] > 0 {
				present[grid[i][j]] = true
			}
		}
	}

	colorMap := make([]int, k+1)
	C := 0
	for v := 1; v <= k; v++ {
		if present[v] {
			colorMap[v] = C
			C++
		}
	}
	for v := 1; v <= k; v++ {
		if !present[v] {
			colorMap[v] = C
			C++
		}
	}

	mappedGrid := make([][]int, n)
	for i := 0; i < n; i++ {
		mappedGrid[i] = make([]int, m)
		for j := 0; j < m; j++ {
			if grid[i][j] > 0 {
				mappedGrid[i][j] = colorMap[grid[i][j]]
			} else {
				mappedGrid[i][j] = -1
			}
		}
	}

	initM := make([]int, k)
	for i := 0; i < k; i++ {
		initM[i] = m
	}

	MOD := int64(1000000007)

	dp := make(map[uint64]int64)
	dp[pack(initM)] = 1

	M := make([]int, k)
	newM := make([]int, k)
	usedM := make([]bool, m+2)

	for r := 0; r < n; r++ {
		for c := 0; c < m; c++ {
			nextDp := make(map[uint64]int64)
			for state, count := range dp {
				unpack(state, M)
				if mappedGrid[r][c] != -1 {
					v := mappedGrid[r][c]
					if c < M[v] {
						copy(newM, M)
						newM[v] = c
						ns := pack(newM)
						nextDp[ns] = (nextDp[ns] + count) % MOD
					}
				} else {
					for i := 0; i <= m; i++ {
						usedM[i] = false
					}
					for v := 0; v < k; v++ {
						if c < M[v] {
							if v >= C {
								if usedM[M[v]] {
									continue
								}
								usedM[M[v]] = true
								ways := 0
								for j := C; j < k; j++ {
									if M[j] == M[v] {
										ways++
									}
								}
								copy(newM, M)
								newM[v] = c
								sortSub(newM, C)
								ns := pack(newM)
								nextDp[ns] = (nextDp[ns] + count*int64(ways)) % MOD
							} else {
								copy(newM, M)
								newM[v] = c
								ns := pack(newM)
								nextDp[ns] = (nextDp[ns] + count) % MOD
							}
						}
					}
				}
			}
			dp = nextDp
			if len(dp) == 0 {
				fmt.Println(0)
				return
			}
		}
	}

	var ans int64 = 0
	for _, count := range dp {
		ans = (ans + count) % MOD
	}
	fmt.Println(ans)
}

func pack(M []int) uint64 {
	var state uint64 = 0
	for i := len(M) - 1; i >= 0; i-- {
		state = (state << 3) | uint64(M[i])
	}
	return state
}

func unpack(state uint64, M []int) {
	for i := 0; i < len(M); i++ {
		M[i] = int(state & 7)
		state >>= 3
	}
}

func sortSub(M []int, C int) {
	for i := C; i < len(M); i++ {
		for j := i; j > C && M[j-1] > M[j]; j-- {
			M[j-1], M[j] = M[j], M[j-1]
		}
	}
}
```