#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 2e5 + 7;
const ll INF = 2e18;

int n, k;
vector<int> g[N];
int a[N];
ll dp[N], dpret[N];

void dfs(int v, int p = -1) {
	if (p != -1) {
		g[v].erase(find(g[v].begin(), g[v].end(), p));
	}
	for (int u : g[v]) {
		dfs(u, v);
	}
	ll sum = 0;
	for (int u : g[v]) {
		sum += a[u];
	}
	{
		dp[v] = a[v];
		for (int u : g[v]) {
			dp[v] = max(dp[v], a[v] + dp[u] - a[u] + sum);
			dp[v] = max(dp[v], a[v] + dpret[u] - a[u] + sum);
		}
		for (int u : g[v]) {
			for (int w : g[v]) {
				if (u != w) {
					dp[v] = max(dp[v], a[v] + dp[u] - a[u] + dpret[w] - a[w] + sum);
				}
			}
		}
	}
	{
		dpret[v] = a[v] + sum;
		for (int u : g[v]) {
			dpret[v] = max(dpret[v], a[v] + dpret[u] - a[u] + sum);
		}
	}
}

vector<int> getordret(int v) {
	ll sum = 0;
	for (int u : g[v]) {
		sum += a[u];
	}
	if (dpret[v] == a[v] + sum) {
		vector<int> ord = {v};
		for (int u : g[v]) {
			ord.push_back(u);
		}
		return ord;
	}
	for (int u : g[v]) {
		if (dpret[v] == a[v] + dpret[u] - a[u] + sum) {
			vector<int> ord = {v};
			auto ordu = getordret(u);
			reverse(ordu.begin(), ordu.end());
			for (int w : ordu) {
				ord.push_back(w);
			}
			for (int w : g[v]) {
				if (w != u) {
					ord.push_back(w);
				}
			}
			return ord;
		}
	}
	assert(0);
	return {v};
}

vector<int> getord(int v) {
	ll sum = 0;
	for (int u : g[v]) {
		sum += a[u];
	}
	if (dp[v] == a[v]) {
		return {v};
	}
	for (int u : g[v]) {
		if (dp[v] == a[v] + dp[u] - a[u] + sum) {
			vector<int> ord = {v};
			for (int w : g[v]) {
				if (w != u) {
					ord.push_back(w);
				}
			}
			auto ordu = getord(u);
			for (int w : ordu) {
				ord.push_back(w);
			}
			return ord;
		}
		if (dp[v] == a[v] + dpret[u] - a[u] + sum) {
			vector<int> ord = {v};
			auto ordu = getordret(u);
			reverse(ordu.begin(), ordu.end());
			for (int w : ordu) {
				ord.push_back(w);
			}
			for (int w : g[v]) {
				if (w != u) {
					ord.push_back(w);
				}
			}
			return ord;
		}
		for (int w : g[v]) {
			if (dp[v] == a[v] + dp[u] - a[u] + dpret[w] - a[w] + sum) {
				vector<int> ord = {v};
				auto ordu = getord(u);
				auto ordw = getordret(w);
				reverse(ordw.begin(), ordw.end());
				for (int l : ordw) {
					ord.push_back(l);
				}
				for (int l : g[v]) {
					if (l != u && l != w) {
						ord.push_back(l);
					}
				}
				for (int l : ordu) {
					ord.push_back(l);
				}
				return ord;
			}
		}
	}
	assert(0);
	return {v};
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin >> n >> k;
	for (int i = 0; i < n - 1; ++i) {
		int v, u;
		cin >> v >> u;
		--v, --u;
		g[v].push_back(u);
		g[u].push_back(v);
	}
	for (int i = 0; i < n; ++i) {
		cin >> a[i];
	}
	dfs(0);
	ll ans = max(dp[0], dpret[0]);
	vector<int> ord;
	if (ans == dp[0]) {
		ord = getord(0);
	} else {
		ord = getordret(0);
	}
	cout << ans << "\n";
	cout << ord.size() << "\n";
	for (int v : ord) {
		cout << v + 1 << " ";
	}
	cout << "\n";
	return 0;	
}