// #pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx")
// #pragma comment(linker, "/stack:200000000"]

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <unordered_set>
#include <unordered_map>
#include <set>
#include <map>
#include <queue>
#include <deque>
#include <bitset>
#include <stack>
#include <random>
#include <fstream>
#include <sstream>
#include <chrono>
#include <cassert>

#define fi first
#define se second
#define pb push_back
#define ll long long
#define ld long double
#define hm unordered_map
#define pii pair<int, int>
#define sz(a) (int)a.size()
#define all(a) a.begin(), a.end()
#define cinv(v) for (auto& x: v) cin >> x
#define fr(i, n) for (int i = 0; i < n; ++i)
#define fl(i, l, n) for (int i = l; i < n; ++i)

#define int ll

template <typename T1, typename T2> inline bool chkmin(T1 &x, const T2 &y) {if (x > y) {x = y; return 1;} return 0;}
template <typename T1, typename T2> inline bool chkmax(T1 &x, const T2 &y) {if (x < y) {x = y; return 1;} return 0;}

using namespace std;

#ifdef LOCAL
	#define dbg(x) cerr << #x << " : " << x << '\n'
	const int maxn = 1000 + 20;
#else
	#define dbg(x)
	const int maxn = 2e5 + 20;
#endif

//tg: @galebickosikasa

ostream& operator << (ostream& out, const pii& v) {
	out << v.fi << ", " << v.se;
	return out;
}

template<typename T> ostream& operator << (ostream& out, const vector<T>& v) {
    for (auto& x: v) out << x << " ";
    return out;
}

istream& operator >> (istream& in, pii& a) {
	in >> a.fi >> a.se;
	return in;
}

const ll inf = (ll) 2e9;
const ld pi = asin (1) * 2;
const ld eps = 1e-8;
const ll mod = (ll)1e9 + 7;
const ll ns = 97;
const int maxlog = 17;

mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());

vector<int> g[maxn], order;
int par[maxn], sz[maxn], dp[maxn], bin[maxn][maxlog], pos[maxn];
int deep[maxn];

void dfs (int v, int p = -1) {
	if (p != -1) deep[v] = deep[p] + 1;
	par[v] = p;
	order.pb (v);
	sz[v] = 1;
	if (p == -1) bin[v][0] = v;
	else bin[v][0] = p;
	fl (i, 1, maxlog) bin[v][i] = bin[bin[v][i - 1]][i - 1];
	for (auto& u: g[v]) {
		if (u != p) {
			dfs (u, v);
			sz[v] += sz[u];
		}
	}
}

void dfs1 (int v, int p = -1) {
	if (p != -1) dp[v] += dp[p];
	// if (v < p) dp[v] -= sz[v];
	++dp[v];
	for (auto& u: g[v]) {
		if (u < p) {
			dp[v] += sz[u];
		}
	}
	for (auto& u: g[v]) {
		if (u != p) dfs1 (u, v);
	}
	dbg (v + 1);
	dbg (dp[v]);
}

int la (int v, int k) {
	for (int i = maxlog - 1; i >= 0; --i) {
		if (k >= (1<<i)) {
			v = bin[v][i];
			k -= (1<<i);
		}
	}
	return v;
}

signed main () {
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	for (auto& x: par) x = inf;
	int n, q;
	cin >> n >> q;
	fr (i, n - 1) {
		int a, b;
		cin >> a >> b;
		--a, --b;
		g[a].pb (b), g[b].pb (a);
	}
	for (auto& v: g) sort (all (v));
	dfs (0);
	fr (i, sz (order)) pos[order[i]] = i;
	dfs1 (0);
	fr (i, q) {
		int k;
		cin >> k;
		int v = (k - 1) / n;
		dbg (v + 1);
		k -= v * n;
		dbg (k);

		int l = -1, r = deep[v] + 2;
		// int l = 0;
		// int u = v;
		// int prev = -1;
		// for (; l < n; ++l) {
		// 	if (dp[v] - dp[u] + 1 <= k && dp[v] - dp[u] + 1 + n - sz[u] > k) {
		// 		prev = u;
		// 		u = par[u];
		// 		continue;
		// 	}
		// }

		while (r - l > 1) {
			int mid = (r + l) / 2;
			int t = la (v, mid);
			dbg (mid);
			dbg (t + 1);
			if (dp[v] - dp[t] + 1 < k && dp[v] - dp[t] + 1 + n - sz[t] >= k) l = mid;
			else r = mid;
		}
		dbg (l);
		dbg (r);

		int u = la (v, l + 1);
		dbg (u + 1);

		int pr = -1;
		if (l >= 0) pr = la (v, l);
		dbg (pr + 1);
		dbg (k);
		dbg (dp[v] - dp[u] + 1);
		dbg (dp[v] - dp[u] + 1 + n - sz[u]);
		if (dp[v] - dp[u] + 1 + n - sz[u] < k) k -= dp[v] - dp[u] + 1 + n - sz[u];
		else k -= dp[v] - dp[u] + 1;
		dbg (k);
		int need = pos[u] + k;
		if (pr != -1 && need >= pos[pr]) need = pos[u] + k + sz[pr];
		// if (need >= sz (order)) exit (0);
		cout << v + 1 << ' ' << order[need] + 1 << '\n';
	}





}