Problem: A pitch-black room

When I woke up, Mr. A was in a pitch-black room. Apparently, Mr. A got lost in a dungeon consisting of N rooms. You couldn't know which room A got lost in, but fortunately he got a map of the dungeon. Let's show A the way to go and lead to a bright room.

It is known that M of the N rooms are pitch black, and the D_1, D_2, ..., and D_Mth rooms are pitch black, respectively. Also, there are exactly K one-way streets from all the rooms in order, and the roads from the i-th room are v_ {i, 1}, v_ {i, 2}, ..., v_ {i, respectively. , K} Connected to the third room. You can follow the a_1, a_2, ..., a_lth roads in order from the room you are in for Mr. A. However, when Mr. A reaches the bright room, he ignores the subsequent instructions. You cannot know the information of the room where Mr. A is currently before and after the instruction, so you must give the instruction sequence so that you can reach the bright room no matter which room you are in. Answer the length of the shortest of such instructions.

Constraints

* 2 ≤ N ≤ 100
* 1 ≤ M ≤ min (16, N − 1)
* 1 ≤ K ≤ N
* 1 ≤ D_i ≤ N
* D_i are all different
* 1 ≤ v_ {i, j} ≤ N
* All dark rooms can reach at least one bright room



Input Format

Input is given from standard input in the following format.


NMK
D_1 D_2 ... D_M
v_ {1,1} v_ {1,2} ... v_ {1,K}
v_ {2,1} v_ {2,2} ... v_ {2, K}
...
v_ {N, 1} v_ {N, 2} ... v_ {N, K}


Output Format

Print the answer in one line.

Sample Input 1


4 2 2
1 2
twenty four
3 1
4 2
13


Sample Output 1


2


<image>
If you give the instruction 1, 1

* If A's initial position is room 1, the second move will reach room 3.
* If A's initial position is room 2, the first move will reach room 3.



Sample Input 2


3 2 2
1 2
twenty three
1 2
twenty one


Sample Output 2


3


<image>
If you give instructions 2, 1, 2

* If A's initial position is room 1, the first move will reach room 3.
* If A's initial position is room 2, the third move will reach room 3.



Sample Input 3


6 3 3
one two Three
4 1 1
2 5 2
3 3 6
4 4 4
5 5 5
6 6 6


Sample Output 3


3


<image>
Beware of unconnected cases and cases with self-edges and multiple edges.





Example

Input

4 2 2
1 2
2 4
3 1
4 2
1 3


Output

2

Solution (in CPP):

Solution:
#define _USE_MATH_DEFINES
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <cstring>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <queue>
#include <deque>
#include <stack>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <numeric>
#include <functional>
#include <cctype>
#include <list>
#include <limits>
#include <cassert>
//#include <boost/multiprecision/cpp_int.hpp>



using namespace std;
using Int = long long;
//using namespace boost::multiprecision;

const double EPS = (1e-10);
long long const MOD = 1000000007;

long long mod_pow(long long x, long long n) {
    long long res = 1;
    for(int i = 0;i < 60; i++){
        if(n >> i & 1) res = res * x % MOD;
        x = x * x % MOD;
    }
    return res;
}

template<typename T>
T gcd(T a, T b) {
    return b != 0 ? gcd(b, a % b) : a;
}

template<typename T>
T lcm(T a, T b) {
    return a * b / gcd(a, b);
}

void fastInput() {
    cin.tie(0);
    ios::sync_with_stdio(false);
}

int dfs(int crt, int color, vector<vector<int>> &G, vector<int> &v) {
    v[crt] = color;
    color ^= 1;
    int ret = 0;
    for (int i = 0; i < G[crt].size(); i++) {
        int nv = G[crt][i];
        if (v[nv] == -1) {
            ret = min(dfs(nv, color, G, v), ret);
        }
        if (v[nv] != color) return -1;
    }
    return ret;
}

vector<int> solve(int N, int M) {
    vector<vector<int>> G(N);

    for (int i = 0; i < M; i++) {
        int u, v; cin >> u >> v;
        u--;
        v--;
        G[u].push_back(v);
        G[v].push_back(u);
    }

    set<int> s;
    for (int i = 0; i < N; i++) {
        vector<int> v(N, -1);
        int check = dfs(i, 0, G, v);
        if (check == -1) continue;
        int cnt = 0;
        for (int j = 0; j < N; j++) {
            if (v[j] == 1) cnt++;
            if (j == N-1) {
                if (cnt % 2) break;
                s.insert(cnt/2);
            }
        }
    }
    
    vector<int> ret;
    for (auto itr = s.begin(); itr != s.end(); itr++) {
        ret.push_back(*itr);
    }
    return ret;
}

int main(void) {
    int N, M, K;
    cin >> N >> M >> K;
    vector<int> D(M);
    for (int i = 0; i < M; i++) {
        cin >> D[i];
        D[i]--;
    }
    vector<vector<int>> G(M);
    for (int i = 0; i < N; i++) {
        for (int k = 0; k < K; k++) {
            int v; cin >> v;
            v--;
            int u = M;
            int flag = 1;
            for (int j = 0; j < M; j++) {
                if (i == D[j]) {
                    u = j;
                }
                if (v == D[j]) {
                    v = j;
                    flag = 0;
                }
            }
            if (u == M) continue;
            if (flag) v = M;
            G[u].push_back(v);
        }
    }
    
    vector<int> state((1 << M));
    int crtState = (1 << (M)) - 1;
    queue<int> q;
    q.push(crtState);
    state[crtState] = 1;
    while (!q.empty()) {
        crtState = q.front();
        q.pop();
        for (int i = 0; i < K; i++) {
            int nextState = 0;
            for (int j = 0; j < M; j++) {
                if ((1 << j) & crtState) {
                    if (G[j][i] == M) continue;
                    nextState |= (1 << G[j][i]);
                }
            }
            if (state[nextState] == 0) {
                state[nextState] = state[crtState] + 1;
                q.push(nextState);
            }
        }
    }
    cout << state[0] - 1 << endl;
}