//#define NDEBUG
#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <array>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <functional>
#include <limits>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
constexpr double PI = 3.1415926535897932;

using int32 = std::int_fast32_t;
using int64 = std::int_fast64_t;
using uint32 = std::uint_fast32_t;
using uint64 = std::uint_fast64_t;
using intl32 = std::int_least32_t;
using intl64 = std::int_least64_t;
using uintl32 = std::uint_least32_t;
using uintl64 = std::uint_least64_t;

const char *yes(bool c) { return c ? "yes" : "no"; }
const char *Yes(bool c) { return c ? "Yes" : "No"; }
const char *YES(bool c) { return c ? "YES" : "NO"; }
const char *pos(bool c) { return c ? "possible" : "impossible"; }
const char *Pos(bool c) { return c ? "Possible" : "Impossible"; }
const char *POS(bool c) { return c ? "POSSIBLE" : "IMPOSSIBLE"; }
template<class T>bool bmaxi(T&a, const T&b) { if (b<a)return 0;a = b;return 1; }
template<class T>bool bmini(T&a, const T&b) { if (a<b)return 0;a = b;return 1; }
template<class T>bool nmaxi(T&a, const T&b) { if (a<b) { a = b;return 1; }return 0; }
template<class T>bool nmini(T&a, const T&b) { if (b<a) { a = b;return 1; }return 0; }
template<typename T>auto scan(T&d)->typename std::enable_if<std::is_signed<T>::value>::type
{
	d = 0;int c = fgetc(stdin);bool f = 0;while (c<'0' || '9'<c) { if (c == '-')f = 1;c = fgetc(stdin); }
	while (c != ' '&&c != '\n') { d = d * 10 + c - '0';c = fgetc(stdin); }if (f)d = -d;
}
template<typename T>auto scan(T&d)->typename std::enable_if<!std::is_signed<T>::value>::type
{
	d = 0;int c = fgetc(stdin);while (c == ' ' || c == '\n')c = fgetc(stdin);
	while (c != ' '&&c != '\n') { d = d * 10 + c - '0';c = fgetc(stdin); }
}
void scan(char&d) { d = fgetc(stdin);while (d == ' ' || d == '\n')d = fgetc(stdin); }
void scan(double&d) { scanf("%lf", &d); }void scan(std::string&d) {
	d.clear();int c = fgetc(stdin);
	while (c == ' ' || c == '\n')c = fgetc(stdin);while (c != ' '&&c != '\n') { d.push_back(c);c = fgetc(stdin); }
}
template<typename F, typename...R>void scan(F&f, R&...r) { scan(f);scan(r...); }
template<typename T>T input() { T d;scan(d);return d; }
template <typename T>auto print(T d)->typename std::enable_if<std::is_signed<T>::value>::type
{
	static int c[20];int i = 0;bool f = 0;if (d<0) { f = 1;d = -d; }while (d) { c[i++] = d % 10;d /= 10; }
	if (!i)c[i++] = 0;if (f)fputc('-', stdout);while (i--)fputc(c[i] + '0', stdout);
}
template<typename T>auto print(T d)->typename std::enable_if<!std::is_signed<T>::value>::type
{
	static int c[20];int i = 0;while (d) { c[i++] = d % 10;d /= 10; }
	if (!i)c[i++] = 0;while (i--)fputc(c[i] + '0', stdout);
}
template<>void print<char>(char d) { fputc(d, stdout); }
template<>void print<double>(double d) { printf("%f", d); }
void print(const char *c) { while (*c != '\0')fputc(*(c++), stdout); }void print() {}
template<typename F, typename...R>void print(F f, R...r) { print(f);print(r...); }
template<typename...R>void println(R...r) { print(r...);fputc('\n', stdout); }
template<typename...R>int END(R...r) { println(r...);return 0; }
#include<iostream>
int main(void) {
	const auto n = input<uint32>();
	std::vector<std::vector<uint32>> G(n);
	for (uint32 i = 1;i < n;++i) {
		uint32 u, v;
		scan(u, v);
		--u, --v;
		G[v].emplace_back(u);
		G[u].emplace_back(v);
	}
	std::vector<uint32> d(n, 0);
	uint32 depth = 0;
	std::function<void(uint32, uint32)> dfs = [&](uint32 v, uint32 prev) {
		d[v] = depth;
		++depth;
		for (const auto e : G[v]) {
			if (e == prev)continue;
			dfs(e, v);
		}
		--depth;
	};
	dfs(0, n);
	uint32 s = std::max_element(d.begin(), d.end()) - d.begin();
	dfs(s, n);
	uint32 t = std::max_element(d.begin(), d.end()) - d.begin();
	std::vector<char> p(n, 0);
	std::function<bool(uint32, uint32)> dfs2 = [&](uint32 v, uint32 prev) {
		if (v == t)return true;
		for (const auto e : G[v]) {
			if (e == prev)continue;
			if (dfs2(e, v)) {
				d.push_back(v);
				return true;
			}
		}
		return false;
	};
	d.clear();
	d.push_back(t);
	dfs2(s, n);
	for (const auto e : d)p[e] = 1;
	for (uint32 i = 0;i < n;++i) {
		if (p[i])continue;
		if (G[i].size() != 1)
			return END("-1");
	}
	for (auto &e : d) {
		e = G[e].size();
	}
	const uint32 siz = d.size();
	for (uint32 i = 0;i < siz/2;++i) {
		uint32 j = siz - i - 1;
		if (d[i] < d[j]) {
			break;
		}
		else if (d[i] > d[j]) {
			std::reverse(d.begin(), d.end());
			break;
		}
	}
	std::vector<uint32> ans;
	d[0] +=1;
	d.back() += 1;
	uint32 acc = 1;
	ans.push_back(1);
	for (uint32 i = 0;i < siz-1;++i) {
		acc += d[i] - 1;
		ans.push_back(acc);
	}
	std::vector<uint32> rans;
	for (uint32 i = 1;i < siz;++i) {
		for (uint32 j = ans[i - 1] + 1; j < ans[i];++j)
			rans.push_back(j);
		rans.push_back(ans[i - 1]);
	}
	rans.push_back(n);
	for (uint32 i = 0;i < n;++i) {
		std::cout << rans[i] << " \n"[i == n - 1];
	}
	return 0;
}

Measured memory_bytes: 18292