The country Treeland consists of *n* cities connected with *n* - 1 bidirectional roads in such a way that it's possible to reach every city starting from any other city using these roads. There will be a soccer championship next year, and all participants are Santa Clauses. There are exactly 2*k* teams from 2*k* different cities.

During the first stage all teams are divided into *k* pairs. Teams of each pair play two games against each other: one in the hometown of the first team, and the other in the hometown of the other team. Thus, each of the 2*k* cities holds exactly one soccer game. However, it's not decided yet how to divide teams into pairs.

It's also necessary to choose several cities to settle players in. Organizers tend to use as few cities as possible to settle the teams.

Nobody wants to travel too much during the championship, so if a team plays in cities *u* and *v*, it wants to live in one of the cities on the shortest path between *u* and *v* (maybe, in *u* or in *v*). There is another constraint also: the teams from one pair must live in the same city.

Summarizing, the organizers want to divide 2*k* teams into pairs and settle them in the minimum possible number of cities *m* in such a way that teams from each pair live in the same city which lies between their hometowns.
The first line of input contains two integers *n* and *k* (2 ≤ *n* ≤ 2·10<sup class="upper-index">5</sup>, 2 ≤ 2*k* ≤ *n*) — the number of cities in Treeland and the number of pairs of teams, respectively.

The following *n* - 1 lines describe roads in Treeland: each of these lines contains two integers *a* and *b* (1 ≤ *a*, *b* ≤ *n*, *a* ≠ *b*) which mean that there is a road between cities *a* and *b*. It's guaranteed that there is a path between any two cities.

The last line contains 2*k* distinct integers *c*<sub class="lower-index">1</sub>, *c*<sub class="lower-index">2</sub>, ..., *c*<sub class="lower-index">2*k*</sub> (1 ≤ *c*<sub class="lower-index">*i*</sub> ≤ *n*), where *c*<sub class="lower-index">*i*</sub> is the hometown of the *i*-th team. All these numbers are distinct.
In the first test the orginizers can settle all the teams in the city number 2. The way to divide all teams into pairs is not important, since all requirements are satisfied anyway, because the city 2 lies on the shortest path between every two cities from {2, 4, 5, 6}.
6 2
1 2
1 3
2 4
2 5
3 6
2 5 4 6
1
2
5 4 2
6 2 2
2 1
1 2
1 2
1
1
2 1 1
6 2
1 6
6 2
6 5
5 3
5 4
1 3 4 2
1
6
4 2 6
3 1 6
10 1
4 2
9 2
1 4
4 10
2 3
7 10
9 6
4 5
8 2
2 9
1
2
9 2 2
10 2
9 2
10 8
2 3
1 3
2 7
10 7
9 4
2 5
6 5
7 8 3 6
1
2
8 6 2
7 3 2
10 3
6 7
2 1
9 5
1 5
10 4
8 3
6 5
10 6
3 6
10 5 1 3 7 4
1
6
4 1 6
3 10 6
5 7 6
8 3
1 3
3 2
3 4
4 5
5 6
4 7
7 8
4 6 8 1 3 2
1
3
8 2 3
6 1 3
4 3 3
10 3
3 4
1 3
5 2
2 6
10 1
3 2
2 9
9 8
7 5
10 9 4 7 5 3
1
3
9 10 3
7 4 3
5 3 3
10 4
8 6
1 7
6 1
5 1
10 3
9 6
7 2
6 3
4 9
6 2 1 5 8 3 9 4
1
6
5 4 6
2 3 6
9 1 6
8 6 6
10 5
2 6
2 1
7 2
4 6
7 10
4 3
3 5
9 6
8 7
10 9 2 7 8 5 6 1 3 4
1
2
9 8 2
5 10 2
3 7 2
4 1 2
6 2 2
10 3
5 9
5 6
3 7
8 7
4 7
1 2
6 7
10 6
2 6
2 5 8 7 9 10
1
6
8 9 6
2 10 6
7 5 6
10 3
4 2
8 5
8 9
5 6
10 7
3 7
1 7
9 2
2 7
1 5 9 7 6 2
1
2
6 1 2
5 7 2
9 2 2
7 2
7 5
2 6
3 6
4 6
7 2
1 7
4 7 1 6
1
7
4 1 7
6 7 7
10 4
2 6
10 7
2 10
2 8
9 5
1 5
4 5
6 3
5 3
6 8 10 9 7 4 1 3
1
3
8 4 3
7 1 3
10 9 3
6 3 3
7 2
1 7
4 5
2 3
6 3
4 1
3 1
5 4 7 3
1
1
5 3 1
4 7 1
10 4
1 10
5 1
10 3
4 9
9 2
2 8
4 6
5 7
8 7
9 3 8 2 5 10 1 6
1
5
6 3 5
9 10 5
2 1 5
8 5 5
10 4
10 3
10 8
9 3
2 5
7 2
1 6
9 4
4 5
4 6
2 4 9 3 1 5 8 10
1
4
8 2 4
10 1 4
3 5 4
9 4 4
10 2
2 6
1 3
3 8
10 9
6 7
7 3
7 4
10 7
7 5
6 2 7 1
1
7
2 1 7
6 7 7
7 2
6 1
6 4
6 5
6 7
6 3
2 6
4 2 3 6
1
6
2 3 6
4 6 6
def process(n, G, A):
    g = [[] for i in range(n+1)]
    for u, v in G:
        g[u].append(v)
        g[v].append(u)
    weights = [0 for i in range(n+1)]
    for x in A:
        weights[x] = 1
    parent = [None for i in range(n+1)]
    total_weight = [0 for i in range(n+1)]
    depth = [[1]]
    parent[1] = -1
    while True:
        next_s = []
        for x in depth[-1]:
            for y in g[x]:
                if parent[y] is None:
                    parent[y] = x
                    next_s.append(y)
        if len(next_s)==0:
            break
        depth.append(next_s)
    while len(depth) > 0:
        row = depth.pop()
        for x in row:
            total_weight[x]+=weights[x]
            if x != 1:
                p = parent[x]
                total_weight[p]+=total_weight[x]
    root = 1
    parent_weight = 0
    while True:
        m = [parent_weight, parent[root]]
        for x in g[root]:
            if root==1 or (x != parent[root]):
                m = max(m, [total_weight[x], x])
        if m[0] > k:
            parent_weight = 2*k-m[0]-weights[root]
            parent[root] = m[1]
            root = m[1]
        else:
            break
    parent = [None for i in range(n+1)]
    List = []
    parent[root] = root
    for x in g[root]:
        start = [x]
        parent[x] = x
        L = []
        if weights[x]==1:
            L.append(x)
        while len(start) > 0:
            next_s = []
            for x1 in start:
                for y1 in g[x1]:
                    if parent[y1] is None:
                        parent[y1] = x
                        if weights[y1]==1:
                            L.append(y1)
                        next_s.append(y1)
            start = next_s
        if len(L) > 0:
            List.append(L)
    print("1")
    print(root)
    List = sorted(List, key=lambda a: len(a))
    for i in range(len(List)-1):
        L1 = List[i]
        L2 = List[i+1]
        while len(L1) > 0:
            x = L1.pop()
            y = L2.pop()
            print(f'{x} {y} {root}')
    if len(List[-1]) > 0:
        x = List[-1][0]
        print(f'{x} {root} {root}')
        
    
            
            
            
    
    

    
    
n, k = [int(x) for x in input().split()]
G = []
for i in range(n-1):
    u, v = [int(x) for x in input().split()]
    G.append([u, v])
A = [int(x) for x in input().split()]
process(n, G, A)