#include <bits/stdc++.h>

#define fst(t) std::get<0>(t)
#define snd(t) std::get<1>(t)
#define thd(t) std::get<2>(t)
#define unless(p) if(!(p))
#define until(p) while(!(p))

using ll = std::int64_t;
using P = std::tuple<int,int>;

const int INF = 1001001001;
int N, M;
std::vector<int> G[100100];
int Q, A;
int dist[100100];
std::queue<P> que;

void dijkstra(int s){
    std::fill(dist + 1, dist + 1 + N, INF);
    dist[s] = 0;
    que.emplace(0, s);

    until(que.empty()){
        int d, v;
        std::tie(d, v) = que.front();
        que.pop();

        if(d > dist[v]){
            continue;
        }

        for(int w : G[v]){
            int di = dist[v] + 1;
            if(di < dist[w]){
                dist[w] = di;
                que.emplace(di, w);
            }
        }
    }
}

int f(int n){
    if(n <= 1){
        return 0;
    }

    return 32 - __builtin_clz(n - 1);
}

int main(){
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);

    std::cin >> N >> M;

    for(int i=0;i<M;++i){
        int p, q;
        std::cin >> p >> q;

        G[p].emplace_back(q);
        G[q].emplace_back(p);
    }

    std::cin >> Q;

    for(int i=0;i<Q;++i){
        std::cin >> A;

        dijkstra(A);

        int c = 0, d = 0;

        for(int j=1;j<=N;++j){
            if(j != A && dist[j] < INF){
                c += 1;
                d = std::max(d, f(dist[j]));
            }
        }

        std::cout << c << " " << d << std::endl;
    }
}