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.

-----Notes-----
For the definition of isomorphism of trees, see wikipedia. Intuitively, two trees are isomorphic when they are the "same" if we disregard the indices of their vertices.

-----Constraints-----
 - 2 \leq n \leq 10^5
 - 1 \leq v_i, w_i \leq n
 - The given graph is a tree.

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

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

-----Sample Input-----
6
1 2
1 3
1 4
1 5
5 6

-----Sample Output-----
1 2 4 5 3 6

If the permutation (1, 2, 4, 5, 3, 6) is used to generate a tree, it looks as follows:

This is isomorphic to the given graph.

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = 'import sys\nreadline = sys.stdin.readline\n\ndef parorder(Edge, p):\n    N = len(Edge)\n    par = [0]*N\n    par[p] = -1\n    stack = [p]\n    order = []\n    visited = set([p])\n    ast = stack.append\n    apo = order.append\n    while stack:\n        vn = stack.pop()\n        apo(vn)\n        for vf in Edge[vn]:\n            if vf in visited:\n                continue\n            visited.add(vf)\n            par[vf] = vn\n            ast(vf)\n    return par, order\n\ndef getcld(p):\n    res = [[] for _ in range(len(p))]\n    for i, v in enumerate(p[1:], 1):\n        res[v].append(i)\n    return res\n\ndef dfs(St):\n    dist = [0]*N\n    stack = St[:]\n    used = [False]*N\n    for s in St:\n        used[s] = True\n    while stack:\n        vn = stack.pop()\n        for vf in Edge[vn]:\n            if not used[vf]:\n                used[vf] = True\n                dist[vf] = 1 + dist[vn]\n                stack.append(vf)\n    return dist\n\nN = int(readline())\nEdge = [[] for _ in range(N)]\nfor _ in range(N-1):\n    a, b = map(int, readline().split())\n    a -= 1\n    b -= 1\n    Edge[a].append(b)\n    Edge[b].append(a)\n\ndist0 = dfs([0])\nfs = dist0.index(max(dist0))\ndistfs = dfs([fs])\nen = distfs.index(max(distfs))\ndisten = dfs([en])\n\nDia = distfs[en]\npath = []\nfor i in range(N):\n    if distfs[i] + disten[i] == Dia:\n        path.append(i)\n\nif max(dfs(path)) > 1:\n    print(-1)\nelse:\n    \n    path.sort(key = lambda x: distfs[x])\n    \n    cnt = 1\n    hold = 0\n    perm1 = [None]*N\n    onpath = set(path)\n    idx = 0\n    for i in range(Dia+1):\n        vn = path[i]\n        hold = 0\n        for vf in Edge[vn]:\n            if vf in onpath:\n                continue\n            hold += 1\n            perm1[idx] = cnt + hold\n            idx += 1\n        perm1[idx] = cnt\n        idx += 1\n        cnt = cnt+hold+1\n    \n    cnt = 1\n    hold = 0\n    perm2 = [None]*N\n    onpath = set(path)\n    idx = 0\n    for i in range(Dia+1):\n        vn = path[Dia-i]\n        hold = 0\n        for vf in Edge[vn]:\n            if vf in onpath:\n                continue\n            hold += 1\n            perm2[idx] = cnt + hold\n            idx += 1\n        perm2[idx] = cnt\n        idx += 1\n        cnt = cnt+hold+1\n    print(*min(perm1, perm2))'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 14513