output_description: If there is no permutation that can generate a tree isomorphic to Takahashi's
  favorite tree, print `-1`. If it exists, print the lexicographically smallest
  such permutation, with spaces in between.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      n
      v_1 w_1
      v_2 w_2
      :
      v_{n-1} w_{n-1}
attempt: import sys
  
  readline = sys.stdin.readline
  
  
  def parorder(Edge, p):
      N = len(Edge)
      par = [0] * N
      par[p] = -1
      stack = [p]
      order = []
      visited = set([p])
      ast = stack.append
      apo = order.append
      while stack:
          vn = stack.pop()
          apo(vn)
          for vf in Edge[vn]:
              if vf in visited:
                  continue
              visited.add(vf)
              par[vf] = vn
              ast(vf)
      return par, order
  
  
  def getcld(p):
      res = [[] for _ in range(len(p))]
      for i, v in enumerate(p[1:], 1):
          res[v].append(i)
      return res
  
  
  def dfs(St):
      dist = [0] * N
      stack = St[:]
      used = [False] * N
      for s in St:
          used[s] = True
      while stack:
          vn = stack.pop()
          for vf in Edge[vn]:
              if not used[vf]:
                  used[vf] = True
                  dist[vf] = 1 + dist[vn]
                  stack.append(vf)
      return dist
  
  
  N = int(readline())
  Edge = [[] for _ in range(N)]
  for _ in range(N - 1):
      a, b = map(int, readline().split())
      a -= 1
      b -= 1
      Edge[a].append(b)
      Edge[b].append(a)
  
  dist0 = dfs([0])
  fs = dist0.index(max(dist0))
  distfs = dfs([fs])
  en = distfs.index(max(distfs))
  disten = dfs([en])
  
  Dia = distfs[en]
  if Dia <= 2:
      print(*list(range(1, N + 1)))
  else:
      path = []
      for i in range(N):
          if distfs[i] + disten[i] == Dia:
              path.append(i)
  
      if max(dfs(path)) > 1:
          print(-1)
      else:
  
          path.sort(key=lambda x: distfs[x])
  
          cnt = 1
          hold = 0
          perm1 = [None] * N
          onpath = set(path)
          idx = 0
          for i in range(Dia + 1):
              vn = path[i]
              hold = 0
              for vf in Edge[vn]:
                  if vf in onpath:
                      continue
                  hold += 1
                  perm1[idx] = cnt + hold
                  idx += 1
              perm1[idx] = cnt
              idx += 1
              cnt = cnt + hold + 1
  
          cnt = 1
          hold = 0
          perm2 = [None] * N
          onpath = set(path)
          idx = 0
          for i in range(Dia + 1):
              vn = path[Dia - i]
              hold = 0
              for vf in Edge[vn]:
                  if vf in onpath:
                      continue
                  hold += 1
                  perm2[idx] = cnt + hold
                  idx += 1
              perm2[idx] = cnt
              idx += 1
              cnt = cnt + hold + 1
          print(*min(perm1, perm2))
  
problem_description: Statement
  
  Takahashi has an ability to generate a tree using a permutation
  (p_1,p_2,...,p_n) of (1,2,...,n), in the following process:
  
  First, prepare Vertex 1, Vertex 2, ..., Vertex N. For each i=1,2,...,n,
  perform the following operation:
  
    * If p_i = 1, do nothing.
    * If p_i \neq 1, let j' be the largest j such that p_j < p_i. Span an edge between Vertex i and Vertex j'.
  
  Takahashi is trying to make his favorite tree with this ability. His favorite
  tree has n vertices from Vertex 1 through Vertex n, and its i-th edge connects
  Vertex v_i and w_i. Determine if he can make a tree isomorphic to his favorite
  tree by using a proper permutation. If he can do so, find the
  lexicographically smallest such permutation.
samples: [{"input": "6\n    1 2\n    1 3\n    1 4\n    1 5\n    5 6", "output": "1 2 4 5 3 6\n    \n\nIf the permutation (1, 2, 4, 5, 3, 6) is used to generate a tree, it looks as\nfollows:\n\n![](https://img.atcoder.jp/arc095/db000b879402aed649a1516620eb1e21.png)\n\nThis is isomorphic to the given graph.\n\n* * *"}, {"input": "6\n    1 2\n    2 3\n    3 4\n    1 5\n    5 6", "output": "1 2 3 4 5 6\n    \n\n* * *"}, {"input": "15\n    1 2\n    1 3\n    2 4\n    2 5\n    3 6\n    3 7\n    4 8\n    4 9\n    5 10\n    5 11\n    6 12\n    6 13\n    7 14\n    7 15", "output": "-1"}]