//With diy tree
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class FlagsIoana2 {
    private static int N,K,T;
    private static final long Prime = 1000000007;
    private static long nfact;

    public static class Node{
        public Object[] children;
 
        public Node() {
            children = new Object[N+1];
            for (int i = 0; i<=N; ++i)
                children[i] = null;
        }
    }

    public static class Tree{
        public Node root;
        public ArrayList<int[]> cycles;
        public ArrayList<Node> parents;

        public Tree(){
            root = new Node();
            cycles = new ArrayList<int[]>();
            parents = new ArrayList<Node>();
        }

        public void addToCount(int[] cycle, long toadd) {
            int i = 1;
            Node crt = root;
            while (i<=N-1 ) {
                if (crt.children[cycle[i]] == null) 
                    crt.children[cycle[i]] = new Node();
                crt = (Node)(crt.children[cycle[i]]);
                i++;
            }
            if (crt.children[cycle[N]] == null) {
            	crt.children[cycle[N]] = new Long(toadd);
            	cycles.add(cycle);
            	parents.add(crt);
            } else //just add
            	crt.children[cycle[N]] = new Long((toadd+((Long)crt.children[cycle[N]]).longValue())%Prime);
        }
        
        public Long get(int[] cycle) {
        	Node crt = root;
        	for (int i = 1; i<N; ++i) {
        		crt = (Node)(crt.children[cycle[i]]);
        		if (crt == null)
        			return null;
        	}
        	return (Long)(crt.children[cycle[N]]);
        }
    }
    
    private static Tree oldcounts;
    private static Tree newcounts;
    

    private static long fastexp(long b, long e) {
        long fe = 1;
        while (e > 0) {
            if (e%2 == 1) 
                fe = (fe*b) % Prime;
            b = (b * b) %Prime;
            e = e/2;
        }
        return fe;
    }

    private static void computeall() {
        //compute unnormalized counts       
        int[] cycles = new int[N+1];
        for (int i = 0; i<=N; ++i)
            cycles[i] = 0;
        cycles[1] = N;
        oldcounts = new Tree();  
        oldcounts.addToCount(cycles,(long)1);
        
        for (int i = 0; i<K; ++i) {
            newcounts = new Tree();
            int oldsize = oldcounts.cycles.size();
        	for (int cc = 0; cc < oldsize; cc++) {
        		int[] oldcycles = oldcounts.cycles.get(cc);
                long oldcount = (Long)(oldcounts.parents.get(cc).children[oldcycles[N]]);
                for (int j = 1; j<=N; ++j) if (oldcycles[j] != 0) {

                	 //swap inside one cycle, it breaks the cycle in two            
                	 long combis = j * oldcycles[j];
                	 long totaladd = combis * oldcount;
                	 for (int length1 = 1; length1<=j/2; length1 ++) {
                         cycles = new int[N+1];
                         for (int jj = 0; jj<=N; ++jj)
                	          cycles[jj] = oldcycles[jj];
                         cycles[j]--; 
                		 cycles[length1]++;
                		 cycles[j-length1]++;
         
                         if (j%2 == 0 && length1 == j/2) 
                			newcounts.addToCount(cycles, (totaladd/2)%Prime);
                		 else 
                			newcounts.addToCount(cycles, totaladd % Prime);
                	 }
                     
                     //swap among same-length cycles, it merges the cycles   	 
                     if (oldcycles[j]>=2) {
                	    combis = j * j * oldcycles[j] * (oldcycles[j]-1) / 2;
                	    totaladd = ( combis * oldcount) % Prime;

                        cycles = new int[N+1];
                        for (int jj = 0; jj<=N; ++jj)
                	          cycles[jj] = oldcycles[jj];
                	    cycles[j]-=2;
                	    cycles[2*j]+=1;

                	    newcounts.addToCount(cycles,totaladd % Prime );
                     }
                	 
                	 //swap among different-length cycles, it merges the cycles	 
                	 for (int other = j+1; other<=N; other++) if (oldcycles[other]!=0) {
                		 combis = j * other * oldcycles[j] * oldcycles[other] ;
                    	 totaladd = ( combis * oldcount) % Prime;
                            
                         cycles = new int[N+1];
                         for (int jj = 0; jj<=N; ++jj)
                	          cycles[jj] = oldcycles[jj];
                    	 cycles[other]--;
                         cycles[j]--;
                    	 cycles[j+other]++;

                    	 newcounts.addToCount(cycles,totaladd%Prime);
                	 }
                }
        	}
            oldcounts = newcounts; 
        }
        
        //normalize
        
        int oldsize = oldcounts.cycles.size();
    	for (int cc = 0; cc < oldsize; cc++) {
    		int[] cycle = oldcounts.cycles.get(cc);
            long count = (Long)(oldcounts.parents.get(cc).children[cycle[N]]);
            for (int i = 1 ; i <=N ; ++i) if (cycle[i] > 0 ) {
                count = (count * fastexp(i,cycle[i])) %Prime;
                for (int j = 2; j<=cycle[i]; ++j)
                    count = (count* j) % Prime;
            }
            count = (count * fastexp(nfact,Prime-2)) % Prime;
            oldcounts.parents.get(cc).children[cycle[N]]=new Long(count);
        }
    }
 
	private static void solve() throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		String[] line = br.readLine().split(" ");
        N = Integer.parseInt(line[0]);
		K = Integer.parseInt(line[1]);
        T = Integer.parseInt(line[2]);

        nfact = 1;
        for (int i = 2; i<=N;++i)
            nfact = (nfact*((long)i)) % Prime;
        
        computeall();

        int[] perm = new int[N];
        int[] cycleArray = new int[N+1];
        boolean[] seen = new boolean[N];

        for (int i = 0; i<T; ++i) {
            line = br.readLine().split(" ");
            for (int j = 0; j<N; ++j) {
                perm[j] = Integer.parseInt(line[j])-1;
                seen[j] = false;
            }
            for (int j = 0; j<=N; ++j)
                cycleArray[j] = 0;
            for (int j = 0; j<N; ++j) if (!seen[j]) {
                int length = 0;
                int crt = j;
                do {
                    seen[crt] = true;
                    length++;
                    crt = perm[crt];
                } while (crt != j);
                
                cycleArray[length]++;
            }
            Long count = oldcounts.get(cycleArray);
            System.out.println(count == null?0:count);
         }

	}

	public static void main(String[] args) throws IOException {
		solve();
	}
}