Problem: 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 2k teams from 2k 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 2k 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 2k 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.

Input

The first line of input contains two integers n and k (2 ≤ n ≤ 2·105, 2 ≤ 2k ≤ 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 2k distinct integers c1, c2, ..., c2k (1 ≤ ci ≤ n), where ci is the hometown of the i-th team. All these numbers are distinct.

Output

The first line of output must contain the only positive integer m which should be equal to the minimum possible number of cities the teams can be settled in.

The second line should contain m distinct numbers d1, d2, ..., dm (1 ≤ di ≤ n) denoting the indices of the cities where the teams should be settled.

The k lines should follow, the j-th of them should contain 3 integers uj, vj and xj, where uj and vj are the hometowns of the j-th pair's teams, and xj is the city they should live in during the tournament. Each of the numbers c1, c2, ..., c2k should occur in all uj's and vj's exactly once. Each of the numbers xj should belong to {d1, d2, ..., dm}.

If there are several possible answers, print any of them.

Example

Input

6 2
1 2
1 3
2 4
2 5
3 6
2 5 4 6


Output

1
2
5 4 2
6 2 2

Note

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}.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
class CCity;
class CTree;
class CCity {
 public:
  CCity(unsigned long nIndex, CTree *PTree);
  ~CCity() {}
  void attachOtherCity(CCity *pOtherCity);
  void setTeamFlag();
  void investigateBranches(unsigned long nParentCity);
  bool isBalance(int balance);
  CTree *pTree;
  unsigned long parent;
  unsigned long index;
  vector<CCity *> adjs;
  bool hasTeam;
  int subTeamNum;
};
CCity::CCity(unsigned long nIndex, CTree *tree) {
  index = nIndex;
  pTree = tree;
  hasTeam = false;
  subTeamNum = 0;
}
void CCity::attachOtherCity(CCity *pOtherCity) { adjs.push_back(pOtherCity); }
void CCity::setTeamFlag() { hasTeam = true; }
void CCity::investigateBranches(unsigned long nParentCity) {
  parent = nParentCity;
  if (hasTeam) {
    subTeamNum++;
  }
  for (unsigned long i = 0; i < adjs.size(); i++) {
    if (adjs[i]->index != nParentCity) {
      adjs[i]->investigateBranches(index);
      subTeamNum += adjs[i]->subTeamNum;
    }
  }
}
bool CCity::isBalance(int balance) {
  for (unsigned long i = 0; i < adjs.size(); i++) {
    if (adjs[i]->parent == index and adjs[i]->subTeamNum > balance) {
      return false;
    }
  }
  if (subTeamNum >= balance) {
    return true;
  }
  return false;
}
class CTree {
 public:
  CTree(int nCityNum);
  ~CTree();
  void attachCity(unsigned long nCityA, unsigned long nCityB);
  void setTeamFlag(unsigned long nCity);
  void investigateALLBranches(unsigned long root = 1);
  unsigned long findBalanceCity(int balance);
  vector<unsigned long> getDFSTeams(unsigned long root);
  vector<CCity *> cities;
};
CTree::CTree(int nCityNum) {
  cities.resize(nCityNum + 1);
  for (unsigned long index = 1; index < cities.size(); index++) {
    cities[index] = new CCity(index, this);
  }
}
CTree::~CTree() {
  for (unsigned long index = 1; index < cities.size(); index++) {
    delete cities[index];
  }
}
void CTree::attachCity(unsigned long nCityA, unsigned long nCityB) {
  cities[nCityA]->attachOtherCity(cities[nCityB]);
  cities[nCityB]->attachOtherCity(cities[nCityA]);
}
void CTree::setTeamFlag(unsigned long nCity) { cities[nCity]->setTeamFlag(); }
void CTree::investigateALLBranches(unsigned long root) {
  cities[root]->investigateBranches(0);
}
unsigned long CTree::findBalanceCity(int balance) {
  unsigned long index;
  for (index = 1; index < cities.size(); index++) {
    if (cities[index]->isBalance(balance)) {
      break;
    }
  }
  return index;
}
vector<unsigned long> CTree::getDFSTeams(unsigned long root) {
  vector<unsigned long> teams;
  stack<CCity *> dfs;
  cities[root]->parent = 0;
  dfs.push(cities[root]);
  while (not dfs.empty()) {
    CCity *city = dfs.top();
    dfs.pop();
    if (city->hasTeam) {
      teams.push_back(city->index);
    }
    for (unsigned long i = 0; i < city->adjs.size(); i++) {
      if (city->parent != city->adjs[i]->index) {
        city->adjs[i]->parent = city->index;
        dfs.push(city->adjs[i]);
      }
    }
  }
  return teams;
}
int main() {
  ios_base::sync_with_stdio(false);
  int N, K;
  while (cin >> N >> K) {
    CTree *tree = new CTree(N);
    for (int i = 1; i < N; i++) {
      unsigned long ca, cb;
      cin >> ca >> cb;
      tree->attachCity(ca, cb);
    }
    for (int i = 0; i < 2 * K; i++) {
      unsigned long c;
      cin >> c;
      tree->setTeamFlag(c);
    }
    tree->investigateALLBranches();
    unsigned long settled_in_city = tree->findBalanceCity(K);
    vector<unsigned long> teams = tree->getDFSTeams(settled_in_city);
    cout << 1 << endl;
    cout << settled_in_city << endl;
    for (int i = 0; i < K; i++) {
      cout << teams[i] << " " << teams[i + K] << " " << settled_in_city << endl;
    }
    delete tree;
  }
  return 0;
}