#include <bits/stdc++.h>
using namespace std;


#define ll long long
#define vl vector<long long>
#define vll vector<vector<long long>>

vector<set<ll>> graf;
ll n;
vector<bool> start, target, solved;
vl current, nei, need, waitfor;


ll dfs(ll i, ll p){
    ll s = target[i]-start[i];
    if (graf[i].empty()){
        return 0;
    }

    vl td;
    for (ll x : graf[i]){
        if (x != p){
            ll sub = dfs(x, i);
            if (sub == 0){
                td.push_back(x);
            }
            need[x] = sub;
            s += sub;
            if (sub < 0){
                waitfor[i]++;
            }
        }
    }

    for (auto x : td){
        graf[i].erase(x);
        graf[x].erase(i);
    }
    if (s > 0){
        waitfor[i]++;
    }
    return s;
}

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

    cin >> n;
    graf.resize(n);
    start.resize(n, false);
    target.resize(n, false);
    solved.resize(n, false);

    need.resize(n, 0);
    waitfor.resize(n, 0);

    current.resize(n, 0);
    nei.resize(n, 0);

    for (ll i = 0; i < n-1; i++){
        ll a,b;
        cin >> a >> b;
        graf[b].insert(a);
        graf[a].insert(b);
    }

    ll k;
    cin >> k;
    for (ll i = 0; i < k; i++){
        ll a;
        cin >> a;
        start[a] = true;
        current[a]++;
    }

    for (ll i = 0; i < k; i++){
        ll a;
        cin >> a;
        target[a] = true;
    }

    dfs(0, -1);



    vl pending;
    vll ans;
    for(ll i = 0; i < n; i++){
        if ((target[i] == false || current[i] == 1) && graf[i].size() == 1){
            pending.push_back(i);
        }
    }

    while (pending.empty() == false){
        ll s = pending.size() -1;
        ll pos = pending[s];
        pending.pop_back();

        solved[pos] = true;
        for (auto x : graf[pos]){
            nei[x]++;
        }

        if (target[pos] == true){
            current[pos]--;
        }

        for (auto x : graf[pos]){
            if (solved[x] == false){
                if (need[x] != 0 && current[pos] != 0){
                    ans.push_back({pos, x, min(need[x], current[pos])});
                    current[x] += min(need[x], current[pos]);
                    current[pos] -= min(need[x], current[pos]);
                }
            
                if (nei[x] >= waitfor[x]){
                    pending.push_back(x);
                }
            }
        }
    }

    cout << ans.size() << "\n";
    for (ll i = 0; i < ans.size(); i++)
        cout << ans[i][0] <<  " " << ans[i][1] << " " << ans[i][2] << "\n";
    return 0;
}