#include <bits/stdc++.h>

using namespace std;

using ll = long long;
#define all(x) begin(x), end(x)
#define rep(i,a,b) for (auto i = a; i < (b); ++i)
#define vi vector<int>
#define pii pair<int,int>

#define W(x) cerr << #x << ": " << (x) << "\n";
//#define W(x) (void)x

int n;
vector<set<int>> g;
vector<int> curr;
vector<int> wanted;
int rc = 0;
vector<int> marker;
vector<int> depths;

void print_col(const set<int> &r) {
	return;
	const char *sep = "{";
	for (const auto &e : r) {
		cerr << sep << e;
		sep = ", ";
	}
	cerr << "}\n";
}

vector<tuple<int,int,int>> commands;
void move(int from, int to, int count) {
	assert(from != to);

	commands.emplace_back(from, to, count);

	curr[from] -= count;
	assert(curr[from] >= 0);
	curr[to] += count;
}

int calc_depths(int node, int prev) {
	depths[node] = 0;
	for (int c : g[node]) {
		if (c == prev)
			continue;
		depths[node] = max(depths[node], calc_depths(c, node));
	}
	return depths[node] + 1;
}

int deepest_child(int node, int prev) {
	int ret = -1;
	int md = 0;

	for (int c : g[node]) {
		if (c == prev)
			continue;
		if (md <= depths[c]) {
			ret = c;
			md = depths[c];
		}
	}
	assert(ret != -1);
	return ret;
}

int find_leaf(int node) {
	while (g[node].size() != 1)
		node = *g[node].begin();
	return node;
}

int find_centroid(int node) {
	node = find_leaf(node);

	int max_depth = calc_depths(node, -1);
	int max_depth_half = max_depth / 2;

	int prev = -1;
	int curr = node;
	rep(i, 0, max_depth_half) {
		prev = exchange(curr, deepest_child(curr, prev));
		W(curr);
	}
	return curr;
}

int wanted_count(int node, int prev) {
	int ret = wanted[node] - curr[node];
	for (int c : g[node]) {
		if (c == prev)
			continue;
		ret += wanted_count(c, node);
	}
	return ret;
}

void rec(int node) {
	W(node);

	if (g[node].empty())
		return;

	int center = find_centroid(node);
	W(center);
	W(g[center].size());
	print_col(g[center]);
	vector<tuple<int, int>> cw;
	
	for (int c : g[center]) {
		W(c);
		print_col(g[c]);
		int wc = wanted_count(c, center);
		cw.emplace_back(wc, c);

		g[c].erase(center);

		W(wc);
	}
	g[center].clear();

	sort(all(cw));
	for (auto [wc, c] : cw) {
		if (wc > 0)
			move(center, c, wc);
		rec(c);
		if (wc < 0)
			move(c, center, -wc);
	}
}

int main () {
	cin.tie(0)->sync_with_stdio(0);

	cin >> n;
	g.resize(n);
	curr.resize(n);
	wanted.resize(n);
	depths.resize(n);

	rep(i,1,n) {
		int a,b;
		cin >> a >> b;
		assert(a != b);
		g[a].insert(/*g[a].end(), */b);
		g[b].insert(/*g[b].end(), */a);
	}

	int k;
	cin >> k;
	rep(i,0,k) {
		int x;
		cin >> x;
		++curr[x];
	}
	rep(i,0,k) {
		int x;
		cin >> x;
		++wanted[x];
	}

	rec(0);

	cout << commands.size() << '\n';
	for (auto [from,to,count] : commands)
		cout << from << ' ' << to << ' ' << count <<  '\n';

	return 0;
}