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 = "#!/usr/bin/env python3\n\n\ndef solve(n, adj_list, d):\n\n    s = []\n    path_adj_list = [[] for _ in range(n)]\n    for v in range(n):\n        if 1 < d[v]:\n            p = path_adj_list[v]\n            for w in adj_list[v]:\n                if 1 < d[w]:\n                    p.append(w)\n            if 2 < len(p):\n                print((-1))\n                return\n            if len(p) == 1:\n                s.append(v)\n\n    if len(s) == 0:\n        ans = [1] + [v for v in range(3, n)] + [2]\n        if 2 < n:\n            ans += [n]\n        print((' '.join(list(map(str, ans)))))\n        return\n\n    visited = [False] * n\n    v, w = s\n    while v != w and d[v] == d[w]:\n        visited[v] = True\n        visited[w] = True\n        f = False\n        for nv in path_adj_list[v]:\n            if not visited[nv]:\n                f = True\n                v = nv\n                break\n        if not f:\n            break\n        f = False\n        for nw in path_adj_list[w]:\n            if not visited[nw]:\n                f = True\n                w = nw\n                break\n        if not f:\n            break\n\n    if d[v] > d[w]:\n        v = s[1]\n    else:\n        v = s[0]\n\n    visited = [False] * n\n    visited[v] = True\n    ans = [1] + [w for w in range(3, d[v] + 1)] + [2]\n    c = d[v]\n    v = path_adj_list[v][0]\n    while True:\n        visited[v] = True\n        ans += [w for w in range(c + 2, c + d[v])] + [c + 1]\n        c += d[v] - 1\n        f = False\n        for nv in path_adj_list[v]:\n            if not visited[nv]:\n                f = True\n                v = nv\n                break\n        if not f:\n            break\n\n    ans += [n]\n\n    print((' '.join(list(map(str, ans)))))\n    return\n\n\ndef main():\n    n = input()\n    n = int(n)\n    adj_list = [[] for _ in range(n)]\n    d = [0] * n\n    for _ in range(n - 1):\n        v, w = input().split()\n        v = int(v) - 1\n        w = int(w) - 1\n        adj_list[v].append(w)\n        adj_list[w].append(v)\n        d[v] += 1\n        d[w] += 1\n\n    solve(n, adj_list, d)\n\n\ndef __starting_point():\n    main()\n\n\n__starting_point()"
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 14111