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\nfrom collections import deque\n\n\ndef diameter(n, links):\n    q = deque([(0, -1)])\n    v = 0\n    while q:\n        v, p = q.popleft()\n        q.extend((u, v) for u in links[v] if u != p)\n\n    q = deque([(v, -1)])\n    w = 0\n    parents = [-1] * n\n    while q:\n        w, p = q.popleft()\n        parents[w] = p\n        q.extend((u, w) for u in links[w] if u != p)\n    parents_rev = [-1] * n\n    p = w\n    while parents[p] != -1:\n        parents_rev[parents[p]] = p\n        p = parents[p]\n    return v, w, parents, parents_rev\n\n\ndef construct(s, links, parents, parents_rev):\n    v = s\n    result = []\n    while v != -1:\n        pv, rv = parents[v], parents_rev[v]\n        child_count = 0\n        for u in links[v]:\n            if u == pv or u == rv:\n                continue\n            if len(links[u]) != 1:\n                return False\n            child_count += 1\n        my_value = len(result) + 1\n        result.extend(list(range(my_value + 1, my_value + child_count + 1)))\n        result.append(my_value)\n        v = parents[v]\n    return result\n\n\ndef solve(n, links):\n    d1, d2, parents, parents_rev = diameter(n, links)\n    result1 = construct(d1, links, parents_rev, parents)\n    if result1 is False:\n        return [-1]\n    result2 = construct(d2, links, parents, parents_rev)\n    return min(result1, result2)\n\n\nn = int(input())\nlinks = [set() for _ in range(n)]\nINF = 10 ** 9\n\nfor line in sys.stdin:\n    v, w = list(map(int, line.split()))\n    v -= 1\n    w -= 1\n    links[v].add(w)\n    links[w].add(v)\n\nprint((*solve(n, links)))\n'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: