#include <bits/stdc++.h>
int32_t t_cur = 0;
void dfs(int32_t vertex, std::vector<int32_t>* tree, int32_t* tin,
         int32_t* tout, int32_t parent, std::vector<int32_t>& leaves,
         int32_t* parents) {
  tin[vertex] = t_cur++;
  parents[vertex] = parent;
  if (tree[vertex].size() == 1 && vertex != 0) leaves.push_back(vertex);
  for (int32_t i = 0; i < tree[vertex].size(); i++)
    if (tree[vertex][i] != parent)
      dfs(tree[vertex][i], tree, tin, tout, vertex, leaves, parents);
  tout[vertex] = t_cur;
}
void build_ans(int32_t vertex, std::vector<int32_t>* tree, int32_t* parents,
               int32_t& cur_leaf, std::vector<int32_t>& leaves_order,
               std::vector<int32_t>& ans, int32_t* tin, int32_t* tout) {
  ans.push_back(vertex);
  int32_t target = cur_leaf < leaves_order.size() ? leaves_order[cur_leaf] : -1;
  if (vertex == target) {
    cur_leaf++;
    target = cur_leaf < leaves_order.size() ? leaves_order[cur_leaf] : -1;
  }
  if (target == -1) {
    if (vertex != 0)
      build_ans(parents[vertex], tree, parents, cur_leaf, leaves_order, ans,
                tin, tout);
  } else if (!(tin[target] >= tin[vertex] && tout[target] <= tout[vertex]))
    build_ans(parents[vertex], tree, parents, cur_leaf, leaves_order, ans, tin,
              tout);
  else {
    int32_t next =
        tree[vertex][0] == parents[vertex] ? tree[vertex][1] : tree[vertex][0];
    for (int32_t i = 0; i < tree[vertex].size(); i++)
      if (tree[vertex][i] != parents[vertex])
        if (tin[target] >= tin[tree[vertex][i]] &&
            tout[target] <= tout[tree[vertex][i]]) {
          next = tree[vertex][i];
          break;
        }
    build_ans(next, tree, parents, cur_leaf, leaves_order, ans, tin, tout);
  }
}
int main() {
  int32_t n;
  std::cin >> n;
  std::vector<int32_t>* tree = new std::vector<int32_t>[n];
  for (int32_t i = 0; i < n - 1; i++) {
    int32_t src, dst;
    std::cin >> src >> dst;
    src--;
    dst--;
    tree[src].push_back(dst);
    tree[dst].push_back(src);
  }
  int32_t *tin = new int32_t[n], *tout = new int32_t[n];
  int32_t* parents = new int32_t[n];
  std::vector<int32_t> leaves;
  dfs(0, tree, tin, tout, -1, leaves, parents);
  std::vector<int32_t> leaves_order;
  leaves_order.resize(leaves.size());
  for (int32_t i = 0; i < leaves.size(); i++) {
    std::cin >> leaves_order[i];
    leaves_order[i]--;
  }
  std::vector<int32_t> ans;
  int32_t cur_leaf = 0;
  build_ans(0, tree, parents, cur_leaf, leaves_order, ans, tin, tout);
  if (ans.size() != 2 * n - 1)
    std::cout << -1;
  else
    for (int32_t i = 0; i < ans.size(); i++) std::cout << ans[i] + 1 << " ";
  return 0;
}
