// Slower C++ solution:
#include <bits/stdc++.h>



using namespace std;



const int N = 123456;

int n, f[N][2], g[N][2], cnt[N];

map<int, int> ind;

vector<int> e[N];



void dfs(int u, int p, int& res, int& pos) {

  f[u][0] = f[u][1] = 1;

  g[u][0] = g[u][1] = 0;

  for (int i = 0; i < e[u].size(); ++i) {

    int v = e[u][i];

    if (v == p) continue;

    dfs(v, u, res, pos);

    if (f[u][0] < f[v][0] + 1) {

      f[u][1] = f[u][0];

      g[u][1] = g[u][0];

      f[u][0] = f[v][0] + 1;

      g[u][0] = v;

    } else if (f[u][1] < f[v][0] + 1) {

      f[u][1] = f[v][0] + 1;

      g[u][1] = v;

    }

  }

  if (res < f[u][0] + f[u][1]) {

    res = f[u][0] + f[u][1] - 1;

    pos = u;

  }

}



vector<int> sol(int m, int a[]) {

  vector<int> r;

  int beg = 1;

  for (int i = 0; i < m; ++i) {

    int end = beg + a[i] - 1;

    

    for (int j = beg + 1; j <= end; ++j) r.push_back(j);

    r.push_back(beg);



    beg = end + 1;

  }

  return r;

}



int cmp(vector<int>& a, vector<int>& b) {

  for (int i = 0; i < a.size(); ++i) {

    if (a[i] != b[i]) return a[i] - b[i];

  }

  return 0;

}



int main() {

  cin >> n;

  for (int i = 0, u, v; i < n - 1; ++i) {

    cin >> u >> v;

    e[u].push_back(v);

    e[v].push_back(u);

  }



  int res = 0, pos;

  dfs(1, 0, res, pos);



//  cout << res << "," << pos << endl;



  deque<int> path;

  for (int i = pos; i; i = g[i][0]) path.push_back(i);

  for (int i = g[pos][1]; i; i = g[i][0]) path.push_front(i);



//  for (int i = 0; i < path.size(); ++i) cout << path[i] << endl;

  for (int i = 0; i < path.size(); ++i) ind[path[i]] = i;

  memset(cnt, 0x00, sizeof(cnt));

  for (int i = 1; i <= n; ++i) {

    if (ind.count(i)) cnt[ind[i]]++;

    else {

      bool found = false;

      for (int j = 0; j < e[i].size(); ++j) {

        int v = e[i][j];

        if (ind.count(v)) {

          cnt[ind[v]]++;

          found = true;

          break;

        }

      }

      if (!found) {

        cout << "-1" << endl;

        return 0;

      }

    }

  }

  

  //for (int i = 0; i < path.size(); ++i) cout << cnt[i] << endl; 



  vector<int> r0 = sol(path.size(), cnt);



  reverse(cnt, cnt + path.size());

  vector<int> r1 = sol(path.size(), cnt);



  if (cmp(r0, r1) <= 0) {

    for (int i = 0; i < r0.size(); ++i) cout << r0[i] << (i == r0.size() - 1 ? "\n" : " ");

  } else {

    for (int i = 0; i < r1.size(); ++i) cout << r1[i] << (i == r0.size() - 1 ? "\n" : " ");

  }



  return 0;



}

// Faster C++ solution for the same problem (measured speedup: 1.3420125202294564x):
#include<bits/stdc++.h>

#define st first

#define nd second

#define pb push_back

#define pf push_front

#define ppb pop_back

#define ppf pop_front

#define umax(x,y) x=max(x,y)

#define umin(x,y) x=min(x,y)

#define ll long long

#define ii pair<int,int>

#define iii pair<int,ii>

#define iiii pair<ii,ii>

#define sz(x) ((int) x.size())

#define orta ((bas+son)/2)

#define all(x) x.begin(),x.end()

#define inf 1000000005

#define MOD 1000000007 

#define N 100005

#define M 1000000

#define LOG 20

#define KOK 300

#define EPS 0.0000001

using namespace std;



int mx,dia,n;

int sub[N],dad[N];

vector<int> v[N];



void dfs(int node,int ata,int dst) {



	dad[node]=ata;

	sub[node]=1;



	if(dst>mx) {



		mx=dst;

		dia=node;



	}



	for(auto x:v[node]) {



		if(x==ata) continue ;



		dfs(x,node,dst+1);



		sub[node]+=sub[x];



	}



}



vector<int> ans;

vector<int> cur;

int val;



void dfs2(int node,int ata) {



	int leaf=0;

	int non=0;



	for(int x:v[node]) {



		if(x==ata) continue ;



		leaf+=(sub[x]==1);

		non+=!(sub[x]==1);



	}



	if(non>1) return ;



	if(non) {



		int tut=++val;



		for(int i=1;i<=leaf;i++) {



			cur.pb(++val);



		}



		cur.pb(tut);



		for(int x:v[node]) {



			if(x==ata || sub[x]==1) continue ;



			dfs2(x,node);



		}

	

	}

	else {



		int tut=++val;



		for(int i=1;i<leaf;i++) {



			cur.pb(++val);



		}



		cur.pb(tut);

		cur.pb(++val);



		if(!sz(ans)) ans=cur;

		else umin(ans,cur);



	}



}



void solve(int node) {



	cur.clear();

	val=0;



	dfs(node,0,0);



	dfs2(node,0);



}



int main() {



	int root=1;



	scanf("%d",&n);



	for(int i=1;i<n;i++) {



		int x,y;



		scanf("%d %d",&x,&y);



		v[x].pb(y);

		v[y].pb(x);



		if(sz(v[x])>1) root=x;

		if(sz(v[y])>1) root=y;



	}



	vector<int> cd;



	mx=0;

	dfs(root,0,0);



	cd.pb(dia);



	mx=0;

	dfs(dia,0,0);



	cd.pb(dia);



	solve(cd[0]);

	solve(cd[1]);



	dfs(root,0,0);



	solve(dad[cd[0]]);

	solve(dad[cd[1]]);



	if(ans.empty()) printf("-1");

	else for(auto x:ans) printf("%d ",x);



}