// Original C++ solution (slower):
#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;



}

// Optimized solution to the same problem (faster):
//#include <bits/stdc++.h>

#include <cstdio>

#include <vector>

using namespace std;



const int N = 100000 + 5;



int n, s, t, d;

vector<int> g[N];



void dfs(int x, int fa, int dis, int &point) {

    if (dis > d) {

        d = dis;

        point = x;

    }

    for (int i = 0; i < g[x].size(); ++i) {

        int y = g[x][i];

        if (y == fa) continue;

        dfs(y, x, dis + 1, point);

    }

}



vector<int> path;

bool color[N];



bool find_path(int x, int fa) {

    path.push_back(x); color[x] = true;

    if (x == t) return true;

    for (int i = 0; i < g[x].size(); ++i) {

        int y = g[x][i];

        if (y == fa) continue;

        if (find_path(y, x)) return true;

    }

    path.pop_back(), color[x] = false;

    return false;

}



bool vis[N];

int cnt[N];

int ans1[N], ans2[N];



int main() {

    scanf("%d", &n);

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

        scanf("%d%d", &a, &b);

        g[a].push_back(b), g[b].push_back(a);

    }

    dfs(1, 0, 0, s), d = 0, dfs(s, 0, 0, t);

    find_path(s, 0);

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

        int x = path[i];

        for (int j = 0; j < g[x].size(); ++j) {

            int y = g[x][j];

            vis[y] = true;

            if (!color[y]) ++cnt[i];

        }

    }

    for (int i = 1; i <= n; ++i) if (!vis[i]) { puts("-1"); return 0; }

    int pos = 1, id = 1;

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

        for (int j = 1; j <= cnt[i]; ++j)

            ans1[pos++] = id + j;

        ans1[pos++] = id;

        id += cnt[i] + 1;

    }

    pos = 1, id = 1;

    for (int i = path.size() - 1; i >= 0; --i) {

        for (int j = 1; j <= cnt[i]; ++j)

            ans2[pos++] = id + j;

        ans2[pos++] = id;

        id += cnt[i] + 1;

    }

    int t = 1;

    for (int i = 1; i <= n; ++i) if (ans1[i] < ans2[i]) { t = 1; break; } else if (ans1[i] > ans2[i]) { t = 2; break; }

    if (t == 1) for (int i = 1; i <= n; ++i) printf("%d%c", ans1[i], i == n ? '\n' : ' ');

    else for (int i = 1; i <= n; ++i) printf("%d%c", ans2[i], i == n ? '\n' : ' ');

    return 0;

}


// Fastest known solution for this problem: