#include <bits/stdc++.h>
using namespace std;
int n, u, v;
vector<int> graph[1600];
int descent[1600];
int nodes[1600];
pair<int, int> vertice[1600];
pair<int, int> rooti;
int root;
int answers[1600];
int countDescent(int node, int pre) {
  for (int i = 0; i < graph[node].size(); ++i)
    if (graph[node][i] != pre)
      descent[node] += countDescent(graph[node][i], node);
  descent[node]++;
  return descent[node];
}
bool comp(int a, int b) {
  return ((double)(vertice[a].second - rooti.second) /
          (double)(vertice[a].first - rooti.first)) <
         ((double)(vertice[b].second - rooti.second) /
          (double)(vertice[b].first - rooti.first));
}
int findRoot(int s, int e) {
  int mx = INT_MAX, my = INT_MAX;
  int root = 0;
  for (int i = s; i < e; ++i) {
    if (vertice[nodes[i]].first < mx ||
        (vertice[nodes[i]].first == mx && vertice[nodes[i]].second < my)) {
      mx = vertice[nodes[i]].first;
      my = vertice[nodes[i]].second;
      root = i;
    }
  }
  return root;
}
void swap(int& a, int& b) {
  int tmp = a;
  a = b;
  b = tmp;
}
void buildTree(int treeRoot, int pre, int l, int r) {
  root = findRoot(l, r);
  rooti = vertice[nodes[root]];
  answers[nodes[root]] = treeRoot;
  swap(nodes[root], nodes[l]);
  sort(nodes + l + 1, nodes + r, comp);
  int start = l + 1;
  if (start != r)
    for (int i = 0; i < graph[treeRoot].size(); ++i) {
      if (graph[treeRoot][i] != pre) {
        buildTree(graph[treeRoot][i], treeRoot, start,
                  start + descent[graph[treeRoot][i]]);
        start += descent[graph[treeRoot][i]];
      }
    }
}
int main() {
  scanf("%d", &n);
  for (int i = 1; i <= n - 1; ++i) {
    scanf("%d %d", &u, &v);
    graph[u].push_back(v);
    graph[v].push_back(u);
  }
  for (int i = 1; i <= n; ++i) {
    scanf("%d %d", &vertice[i].first, &vertice[i].second);
    nodes[i] = i;
  }
  countDescent(1, 1);
  buildTree(1, 1, 1, n + 1);
  for (int i = 1; i <= n; ++i) cout << answers[i] << ' ';
  cout << endl;
}

### Prompt

Please formulate a Cpp solution to the following problem:

You are given a tree with n vertexes and n points on a plane, no three points lie on one straight line.

Your task is to paint the given tree on a plane, using the given points as vertexes. 

That is, you should correspond each vertex of the tree to exactly one point and each point should correspond to a vertex. If two vertexes of the tree are connected by an edge, then the corresponding points should have a segment painted between them. The segments that correspond to non-adjacent edges, should not have common points. The segments that correspond to adjacent edges should have exactly one common point.

Input

The first line contains an integer n (1 ≤ n ≤ 1500) — the number of vertexes on a tree (as well as the number of chosen points on the plane).

Each of the next n - 1 lines contains two space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi) — the numbers of tree vertexes connected by the i-th edge.

Each of the next n lines contain two space-separated integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th point on the plane. No three points lie on one straight line.

It is guaranteed that under given constraints problem has a solution.

Output

Print n distinct space-separated integers from 1 to n: the i-th number must equal the number of the vertex to place at the i-th point (the points are numbered in the order, in which they are listed in the input).

If there are several solutions, print any of them.

Examples

Input

3
1 3
2 3
0 0
1 1
2 0


Output

1 3 2


Input

4
1 2
2 3
1 4
-1 -2
3 5
-3 3
2 0


Output

4 2 1 3

Note

The possible solutions for the sample are given below.

<image> <image>

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
int n, u, v;
vector<int> graph[1600];
int descent[1600];
int nodes[1600];
pair<int, int> vertice[1600];
pair<int, int> rooti;
int root;
int answers[1600];
int countDescent(int node, int pre) {
  for (int i = 0; i < graph[node].size(); ++i)
    if (graph[node][i] != pre)
      descent[node] += countDescent(graph[node][i], node);
  descent[node]++;
  return descent[node];
}
bool comp(int a, int b) {
  return ((double)(vertice[a].second - rooti.second) /
          (double)(vertice[a].first - rooti.first)) <
         ((double)(vertice[b].second - rooti.second) /
          (double)(vertice[b].first - rooti.first));
}
int findRoot(int s, int e) {
  int mx = INT_MAX, my = INT_MAX;
  int root = 0;
  for (int i = s; i < e; ++i) {
    if (vertice[nodes[i]].first < mx ||
        (vertice[nodes[i]].first == mx && vertice[nodes[i]].second < my)) {
      mx = vertice[nodes[i]].first;
      my = vertice[nodes[i]].second;
      root = i;
    }
  }
  return root;
}
void swap(int& a, int& b) {
  int tmp = a;
  a = b;
  b = tmp;
}
void buildTree(int treeRoot, int pre, int l, int r) {
  root = findRoot(l, r);
  rooti = vertice[nodes[root]];
  answers[nodes[root]] = treeRoot;
  swap(nodes[root], nodes[l]);
  sort(nodes + l + 1, nodes + r, comp);
  int start = l + 1;
  if (start != r)
    for (int i = 0; i < graph[treeRoot].size(); ++i) {
      if (graph[treeRoot][i] != pre) {
        buildTree(graph[treeRoot][i], treeRoot, start,
                  start + descent[graph[treeRoot][i]]);
        start += descent[graph[treeRoot][i]];
      }
    }
}
int main() {
  scanf("%d", &n);
  for (int i = 1; i <= n - 1; ++i) {
    scanf("%d %d", &u, &v);
    graph[u].push_back(v);
    graph[v].push_back(u);
  }
  for (int i = 1; i <= n; ++i) {
    scanf("%d %d", &vertice[i].first, &vertice[i].second);
    nodes[i] = i;
  }
  countDescent(1, 1);
  buildTree(1, 1, 1, n + 1);
  for (int i = 1; i <= n; ++i) cout << answers[i] << ' ';
  cout << endl;
}

```