#include <bits/stdc++.h>

using namespace std;
using ll = long long;

struct step {
    ll from;
    ll to;
    ll count;
};

ll needs(vector<ll>& w, ll u, vector<vector<ll>>& adj, ll parent, vector<bool>& t) {
    ll sum = 0;
    for (ll v : adj[u]) {
        if (v == parent) continue;
        sum += needs(w, v, adj, u, t);
    }
    if (t[u]) {
        ++sum;
    }
    w[u] = sum;
    return sum;
}

pair<ll, ll> propUp(ll u, vector<vector<ll>>& adj, ll parent, vector<ll>& a, vector<ll>& w, vector<bool>& lighted, vector<step>& steps, vector<bool>& t) {
    ll below = 0;

    for (ll v : adj[u]) {
        if (v == parent) continue;
        auto p = propUp(v, adj, u, a, w, lighted, steps, t);
        a[u] += p.first;
        below += p.second;
    }

    if (parent == -1) {
        return { 0, a[u] + below };
    }

    bool canUp = true;

    for (ll v : adj[u]) {
        if (v == parent) continue;
        if (!lighted[v]) {
            canUp = false;
            break;
        }
    }

    // cout << a[u] << ";" << w[u] << ";" << below << endl;
    ll capacity = a[u] - (w[u] - below);

    if (capacity <= 0) {
        return { 0, below + a[u] };
    }

    if (!canUp) {
        --capacity;
        lighted[parent] = true;
    }

    if (capacity == 0) {
        return { capacity, a[u] + below };
    }

    a[u] -= capacity;
    steps.push_back({ u, parent, capacity });

    // cout << "u: " << u << " ; " << capacity << " ; " << (below + a[u]) << endl;
    return { capacity, a[u] + below };
}

ll belowC(ll u, vector<vector<ll>>& adj, ll parent, vector<ll>& a, vector<ll>& b) {
    ll sum = a[u];
    for (ll v : adj[u]) {
        if (parent == v) continue;
        sum += belowC(v, adj, u, a, b);
    }
    b[u] = sum;
    return sum;
}

bool propDown(ll u, vector<vector<ll>>& adj, ll parent, vector<ll>& a, vector<ll>& w, vector<step>& steps, vector<ll>& b, vector<bool>& t) {
    ll needsThis = t[u] ? 1 : 0;
    a[u] -= needsThis;

    for (ll v : adj[u]) {
        if (v == parent) continue;
        ll needs = w[v] - b[v];

        // cout << u << ": " << (a[u] + b[v]) << " < " << needs << endl;

        if (needs > 0) {
            if ((a[u]) < needs) {
                return false;
            }
            a[u] -= needs;
            a[v] += needs;
            steps.push_back({ u, v, needs });
        }
        propDown(v, adj, u, a, w, steps, b, t);
    }

    return true;
}

void process() {
    ll n;
    cin >> n;

    vector<vector<ll>> adj(n);

    for (ll i = 0; i < n - 1; ++i) {
        ll u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    ll k;
    cin >> k;

    vector<ll> a(n);
    for (ll i = 0; i < k; ++i) {
        ll u;
        cin >> u;
        ++a[u];
    }

    vector<bool> t(n);
    for (ll i = 0; i < k; ++i) {
        ll u;
        cin >> u;
        t[u] = true;
    }

    vector<ll> w(n);
    needs(w, 0, adj, -1, t);

    vector<bool> lighted(n, false);

    vector<step> steps{};

    vector<ll> b(n);

    propUp(0, adj, -1, a, w, lighted, steps, t);

    belowC(0, adj, -1, a, b);

//    for (ll i = 0; i < n; ++i) {
//        cout << a[i] << " ";
//    }
//    cout << endl;

    if (!propDown(0, adj, -1, a, w, steps, b, t)) {
        cout << "-1\n";
        return;
    }

    cout << steps.size() << "\n";
    for (ll i = 0; i < steps.size(); ++i) {
        step s = steps[i];
        cout << s.from << " " << s.to << " " << s.count << "\n";
    }
}

int main() {
    std::ios::sync_with_stdio(false);
    process();
    cout.flush();
    return 0;
}