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:
#include <iostream>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <queue>

using RoomInfo = std::pair<long long, long long>; //どの部屋に残っているか
using Node = std::pair<RoomInfo, int>; // first, second:cost

namespace std {
    template <>
    class hash<std::pair<long long, long long>> {
    public:
        size_t operator()(const std::pair<long long, long long>& x) const {
            return hash<long long>()(x.first) ^ hash<long long>()(x.second);
        }
    };

    template <>
    class hash<std::pair<RoomInfo, int>> {
    public:
        size_t operator()(const std::pair<RoomInfo, int>& x) const {
            return hash<RoomInfo>()(x.first) ^ hash<int>()(x.second);
        }
    };
}


int main() {
    int n, m, k;
    std::vector<int> d; // is darkroom
    int e[100][100];
    std::queue<Node> q;
    std::unordered_map<RoomInfo, std::vector<RoomInfo>> g; //from, to
    std::unordered_set<RoomInfo> visited;

    std::cin >> n >> m >> k;
    if (m == 0) {
        std::cout << 0 << std::endl; // すべて明るい
        return 0;
    }

    d.resize(n, 0);
    for (int i = 0; i < m; i++) {
        int a;
        std::cin >> a;
        d[a-1] = 1;
    }

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < k; j++) {
            int a;
            std::cin >> a;
            e[i][j] = a-1; // i番目の部屋からj番目の道でaに行く
        }
    }

    // グラフを作成


    RoomInfo node;
    for (int i = 0; i < n; i++) {
        if (d[i]) {
            if (i < 64) {
                node.first |= 1ull << i;
            }
            else {
                node.second |= 1ull << (i - 64);
            }
        }
    }

    q.push(std::make_pair(node, 0));
    visited.insert(node);

    while (!q.empty()) {
        auto node = q.front(); q.pop();
        node.second++;

        // i番目の道を使用
        for (int i = 0; i < k; i++) {
            RoomInfo next = std::make_pair(0, 0);
            // j番目の部屋から移動
            for (int j = 0; j < n; j++) {
                // 居なければcontinue;
                if (j < 64) {
                    if (!(node.first.first & 1ull << j)) continue;
                }
                else {
                    if (!(node.first.second & 1ull<< (j - 64))) continue;
                }
                int to = e[j][i];
                // 移動先も暗い部屋
                if (d[to]) {
                    if (to < 64) next.first |= 1ull << to;
                    else next.second |= 1ull << (to - 64);
                }
            }

            if (!next.first && !next.second) {
                std::cout << node.second << std::endl;
                return 0;
            }
            if (!visited.count(next)) {
                q.push(std::make_pair(next, node.second));
                visited.insert(next);
            }
        }
    }

    return 0;
}