// Slower C++ solution:
#include<iostream>

#include<queue>

using namespace std;



//-----------------------------------LIBRARY OF INPUT-----------------------------------

void reader(int *x) {

	int k = getchar_unlocked(); *x = k - '0';

	while (true) {

		k = getchar_unlocked();

		if (k < '0' || k > '9') break;

		*x = ((*x) << 1) + ((*x) << 3) + k - '0';

	}

}



int n, m, q, dist[110003], mark[110003], u[210003], v[210003];

vector<pair<int, int>>x[110003], y[110003], z[110003]; bool used[210003];

inline bool isgood(int f) {

	for (int i = 0; i < z[f].size(); i++) {

		if (mark[z[f][i].first] == 0 && used[z[f][i].second] == false)return true;

	}

	return false;

}

int main() {

	reader(&n); reader(&m); reader(&q); queue<int>Q;

	for (int i = 0; i < m; i++) {

		int a = 0, b = 0;

		reader(&a);

		reader(&b);

		u[i + 1] = a; v[i + 1] = b;

		x[a].push_back(make_pair(b, i + 1)); x[b].push_back(make_pair(a, i + 1));

	}

	Q.push(1); for (int i = 1; i <= n; i++)dist[i] = 999999; dist[1] = 0;

	while (!Q.empty()) {

		int a1 = Q.front(); Q.pop();

		for (int i = 0; i < x[a1].size(); i++) {

			if (dist[x[a1][i].first] > dist[a1] + 1) { dist[x[a1][i].first] = dist[a1] + 1; Q.push(x[a1][i].first); }

		}

	}

	for (int i = 1; i <= n; i++) {

		for (int j = 0; j < x[i].size(); j++) {

			if (dist[i] < dist[x[i][j].first]) { y[i].push_back(x[i][j]); }

			if (dist[i] > dist[x[i][j].first]) { z[i].push_back(x[i][j]); }

		}

	}

	int cnt = 0;

	for (int i = 0; i < q; i++) {

		int a = 0;

		reader(&a);

		used[a] = true;

		int E1 = u[a], E2 = v[a];

		if (dist[E1] == dist[E2]) { cnt += 0; }

		else {

			int a1 = 0; if (dist[E1] < dist[E2])a1 = E2; else a1 = E1;

			if (mark[a1] == 0 && isgood(a1) == false) {

				queue<int>Q; Q.push(a1); cnt++; mark[a1] = 1;

				while (!Q.empty()) {

					int a2 = Q.front(); Q.pop();

					for (int j = 0; j < y[a2].size(); j++) {

						if (mark[y[a2][j].first] == 0 && isgood(y[a2][j].first) == false) {

							mark[y[a2][j].first] = 1; Q.push(y[a2][j].first); cnt++;

						}

					}

				}

			}

		}

		printf("%d\n", cnt);

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.1031305362775454x):
//-------------------------------------------

//-               Train Fare                -

//-                                         -

//-       autumn_eel niha katemasen!        -

//-------------------------------------------



#include<iostream>

#include<functional>

#include<queue>

#include<deque>

#include<vector>

#include<algorithm>

using namespace std;



void reader(int *x) {

	int k = getchar_unlocked(); *x = k - '0';

	while (true) {

		k = getchar_unlocked();

		if (k < '0') break;

		*x = ((*x) << 1) + ((*x) << 3) + k - '0';

	}

}

inline void writeln(int x) {

	int s = 0; char f[7];

	while (x) {

		f[s++] = x % 10;

		x /= 10;

	}

	if (!s) f[s++] = 0;

	while (s--) putchar_unlocked(f[s] + '0');

	putchar_unlocked('\n');

}

#pragma warning(disable:4996)

int n, m, q, a[200003], b[200003], c[200003], d[200003], e[100003], f[100003], g[100003];

int h1[100003], h2[100003], dist[100003], E[200003];

vector<pair<int, int> > z[100003]; vector<int> x[100003];

vector<int>D[100003];

int main() {

	reader(&n); reader(&m); reader(&q);

	fill(d, d + m + 1, 1 << 30);

	for (int i = 1; i <= m; i++) { reader(&a[i]), reader(&b[i]); f[a[i]]++; f[b[i]]++; }

	for (int i = 1; i <= q; i++) reader(&c[i]), d[c[i]] = i;

	for (int i = 1; i <= n; i++) { x[i].resize(f[i]); }

	for (int i = 1; i <= m; i++) {

		x[a[i]][g[a[i]]] = b[i]; g[a[i]]++;

		x[b[i]][g[b[i]]] = a[i]; g[b[i]]++;

	}

	fill(dist, dist + n + 1, -1); dist[1] = 0;

	queue<int> Q1; Q1.emplace(1);

	while (!Q1.empty()) {

		int a1 = Q1.front(); Q1.pop();

		for (int i : x[a1]) {

			if (dist[i] == -1) {

				dist[i] = dist[a1] + 1;

				Q1.emplace(i);

			}

		}

	}

	for (int i = 1; i <= m; i++) {

		if (dist[a[i]] > dist[b[i]]) h1[a[i]]++;

		if (dist[b[i]] > dist[a[i]]) h1[b[i]]++;

	}

	for (int i = 1; i <= n; i++)z[i].resize(h1[i]);

	for (int i = 1; i <= m; i++) {

		if (dist[a[i]] > dist[b[i]]) { z[a[i]][h2[a[i]]] = make_pair(b[i], d[i]); h2[a[i]]++; }

		if (dist[b[i]] > dist[a[i]]) { z[b[i]][h2[b[i]]] = make_pair(a[i], d[i]); h2[b[i]]++; }

	}

	for (int i = 1; i <= n; i++) D[dist[i]].push_back(i);

	e[1] = (1 << 30);

	for (int i = 1; i < n; i++) {

		for (int j : D[i]) {

			for (pair<int, int>k : z[j]) {

				e[j] = max(e[j], min(e[k.first], k.second));

			}

		}

	}

	for (int i = 2; i <= n; i++) {

		if (e[i] < 300000) E[e[i]]++;

	}

	for (int i = 1; i <= q; i++) {

		E[i] += E[i - 1];

		writeln(E[i]);

	}

	return 0;

}