use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {
        n: usize,
        m: usize,
        edges: [(u32, u32); m],
        k: usize,
        a: [u32; k],
    }

    println!("{}", output(solve(n, prepare(n, edges, a))));
}

fn prepare(n: usize, edges: Vec<(u32, u32)>, a: Vec<u32>) -> (Vec<Vec<u32>>, Vec<bool>) {
    let mut next_of = vec![Vec::with_capacity(100); n + 1];
    for (u, v) in edges {
        next_of[u as usize].push(v);
        next_of[v as usize].push(u);
    }

    let mut is_charming = vec![false; n + 1];
    for a in a {
        is_charming[a as usize] = true;
    }

    (next_of, is_charming)
}

fn solve(n: usize, (next_of, is_charming): (Vec<Vec<u32>>, Vec<bool>)) -> Option<u32> {
    let mut dist = vec![[u32::MAX; 5]; n + 1];
    let mut q = std::collections::VecDeque::with_capacity(n * 5);
    dist[1][0] = 0;
    q.push_back((1, 0));
    while let Some((cur_pos, cur_desire)) = q.pop_front() {
        for next in &next_of[cur_pos as usize] {
            if is_charming[*next as usize] {
                if cur_desire < 4 && dist[*next as usize][(cur_desire + 1) as usize] == u32::MAX {
                    dist[*next as usize][(cur_desire + 1) as usize] =
                        dist[cur_pos as usize][cur_desire as usize] + 1;
                    q.push_back((*next, cur_desire + 1));
                }
            } else {
                if dist[*next as usize][0] == u32::MAX {
                    dist[*next as usize][0] = dist[cur_pos as usize][cur_desire as usize] + 1;
                    q.push_back((*next, 0));
                }
            }
        }
    }

    let ans = dist[n].into_iter().min().unwrap();
    match ans {
        u32::MAX => None,
        _ => Some(ans),
    }
}

fn output(ans: Option<u32>) -> String {
    match ans {
        Some(dist) => dist.to_string(),
        None => String::from("-1"),
    }
}