#!/bin/python3


import sys
points = []
edges = []
adj = {}
n = int(input().strip())
answer = [0 for _ in range (n+1)]
for a0 in range(n-1):
    # An edge connects nodes 'u' and 'v':
    u, v = input().strip().split(' ')
    u, v = [int(u), int(v)]
    edges.append([u,v])
    if u not in adj:
        adj[u] = set()
        adj[u].add(v)
    else:
        adj[u].add(v)
    if v not in adj:
        adj[v] = set()
        adj[v].add(u)
    else:
        adj[v].add(u)
for a0 in range(n):
    # Cartesian coordinate:
    x, y = input().strip().split(' ')
    x, y = [int(x), int(y)]
    points.append([x,y])


def cp(base,a,b):
    q = (a[0]-base[0])*(b[1]-base[1]) - (a[1]-base[1])*(b[0]-base[0])
    return(q)


#def convexhull(pts):
#    pts.sort()
#    if len(pts) <=1:
#        return(pts)
#    else:
#        U = []
 #       L = []
#        for x in pts:
  #          while len(L)>=2 and cp(L[-2],L[-1],x)<=0:
#                L.pop()
#            L.append(x)
#        for x in reversed(pts):
#            while len(U)>=2 and cp(U[-2],U[-1],x)<=0:
#                U.pop()
##            U.append(x)
#        return(L[:-1]+U[:-1])


def slope(a,b):
    if a[0] == b[0]:
        return(10**10)
    else:
        return((b[1]-a[1])/(b[0]-a[0]))


#sort the points by slope with respect to the left bottom most point of convex hull
def slopesort(pts):
    p = sorted(pts)
    x = p.pop(0)
    s = sorted(p,key=lambda y: slope(x,y))
    return(x,s)

children = {}
current = [1]
T = set()
T.add(1)
while current!=[]:
    x = current.pop()
    m = adj[x]-T
    current = current+list(m)
    children[x] = m
    T.add(x)

def subtree(k,child):
    current = [k]
    T = set()
    T.add(k)
    thischildren = {}
    thischildren[k] = child[k]
    while current!=[]:
        x = current.pop()
        m = child[x]-T
        current = current+list(m)
        thischildren[x] = m
        T.add(x)
    return(thischildren)

ccts = {}
def cc(k):
    global ccts
    if k in ccts:
        return(ccts[k])
    if children[k] == set():
        ccts[k] = 0
        return(0)
    else:
        count = 0
        count += len(children[k])
        for i in children[k]:
            count+=cc(i)
        ccts[k] = count
        return(count)

cc(1)



def omfg(par,pts):
    #print(answer)
    ps = sorted(pts)
    x = par
    if len(ps) == 0:
        return
    if len(ps) == 1:
        answer[x] = ps[0]

    else:
        this = slopesort(ps)
        answer[x] = this[0]
        remedges = this[1]

        #print('remedges = ', remedges)
        t = list(children[x])
        arr=[]
        for i in t:
            arr.append(ccts[i])
        #print('arr is ', arr)
        if len(t) == 1:
            omfg(i,remedges)
        else:
            while arr!=[]:
                o = t.pop(0)
                i = arr.pop(0)
                omfg(o,remedges[:i+1])
                remedges = remedges[i+1:]





#        if len(remedges) == 1:
#            a = list(children[x])[0]
#            answer[a] = remedges[0]

#        else:
#            arr=[0]
#            l = list(cs[x])
#            for i in l:
#                arr.append(ccts[i]+arr[-1])
#            print('arr = ', arr)
#            for i in l:
#                m = l.index(i)
#                print('cut up arr', remedges[arr[m]:arr[m+1]])
#                omfg(i,subtree(i,children),remedges[arr[m]:arr[m+1]])




omfg(1,points)
#print(answer)
for i in range(1,n+1):
    print(points.index(answer[i])+1,end=' ')