use std::collections::VecDeque;


const INF: usize = 1usize << 60;

struct UnionFind {
    n: usize,
    parents: Vec<usize>,
}

impl UnionFind {
    fn new(n: usize) -> Self {
        UnionFind {
            n: n,
            parents: (0..n).collect(),
        }
    }

    fn equiv(&mut self, a: usize, b: usize) -> bool {
        self.find(a) == self.find(b)
    }
    
    fn unite(&mut self, a: usize, b: usize) {
        if self.equiv(a, b) { return; }
        let (a, b) = (a.min(b), a.max(b));
        let x = self.parents[a];
        let y = self.parents[b];
        self.parents[y] = self.parents[x];
    }

    fn find(&mut self, a: usize) -> usize {
        if self.parents[a] == a { return a; }
        let p = self.find(self.parents[a]);
        self.parents[a] = p;
        p
    }
}

fn main() {
    let mut nm = String::new();
    std::io::stdin().read_line(&mut nm).ok();
    let nm: Vec<usize> = nm.trim().split_whitespace().map(|s| s.parse().unwrap()).collect();
    let n = nm[0];
    let m = nm[1];
    let mut paths = vec![vec![]; n];
    let mut uf = UnionFind::new(n);
    let mut size = vec![1usize; n];
    for _ in 0..m {
        let mut temp = String::new();
        std::io::stdin().read_line(&mut temp).ok();
        let temp: Vec<usize> = temp.trim().split_whitespace().map(|s| s.parse().unwrap()).collect();
        let p = temp[0]-1;
        let q = temp[1]-1;
        paths[p].push(q);
        paths[q].push(p);
        let pp = uf.find(p);
        let pq = uf.find(q);
        if pp == pq { continue; }
        uf.unite(pp, pq);
        let p = uf.find(pp);
        if p == pp {
            size[pp] += size[pq];
            size[pq] = 0;
        } else {
            size[pq] += size[pp];
            size[pp] = 0;
        }
    }
    let mut q = String::new();
    std::io::stdin().read_line(&mut q).ok();
    let q: usize = q.trim().parse().unwrap();
    let a = (0..q).map(|_| {
            let mut temp = String::new();
            std::io::stdin().read_line(&mut temp).ok();
            let temp: usize = temp.trim().parse().unwrap();
            temp-1
        })
        .collect::<Vec<_>>();

    for &a in a.iter() {
        let mut dists = vec![INF; n];
        dists[a] = 0;
        let mut deque = VecDeque::new();
        deque.push_back(a);
        while let Some(u) = deque.pop_front() {
            for &v in paths[u].iter() {
                if dists[v] < INF { continue; }
                dists[v] = dists[u] + 1;
                deque.push_back(v);
            }
        }
        println!("{} {}", size[uf.find(a)]-1, (*dists.iter().filter(|&&v| v < INF).max().unwrap() as f64).log2().ceil() as usize);
    }
}