Problem: You are given a tree (a graph with n vertices and n - 1 edges in which it's possible to reach any vertex from any other vertex using only its edges).

A vertex can be destroyed if this vertex has even degree. If you destroy a vertex, all edges connected to it are also deleted.

Destroy all vertices in the given tree or determine that it is impossible.

Input

The first line contains integer n (1 ≤ n ≤ 2·105) — number of vertices in a tree.

The second line contains n integers p1, p2, ..., pn (0 ≤ pi ≤ n). If pi ≠ 0 there is an edge between vertices i and pi. It is guaranteed that the given graph is a tree.

Output

If it's possible to destroy all vertices, print "YES" (without quotes), otherwise print "NO" (without quotes).

If it's possible to destroy all vertices, in the next n lines print the indices of the vertices in order you destroy them. If there are multiple correct answers, print any.

Examples

Input

5
0 1 2 1 2


Output

YES
1
2
3
5
4


Input

4
0 1 2 3


Output

NO

Note

In the first example at first you have to remove the vertex with index 1 (after that, the edges (1, 2) and (1, 4) are removed), then the vertex with index 2 (and edges (2, 3) and (2, 5) are removed). After that there are no edges in the tree, so you can remove remaining vertices in any order.

<image>

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
vector<int> g[200001];
bool del[200001];
bool vis[200001];
int cnt[200001];
int evam[200001];
int n;
int dfs(int v) {
  int ans = 1, t;
  vis[v] = 1;
  for (int i = 0; i < g[v].size(); i++) {
    if (!vis[g[v][i]]) {
      t = dfs(g[v][i]);
      ans += t;
      if (!(t & 1)) {
        evam[v]++;
      }
    }
  }
  if (ans != n && !((n - ans) & 1)) {
    evam[v]++;
  }
  return ans;
}
struct cmp {
  bool operator()(const int &a, const int &b) {
    if (evam[a] == evam[b]) {
      if (!(cnt[a] & 1) && (cnt[b] & 1)) {
        return true;
      } else if (!(cnt[b] & 1) && (cnt[a] & 1)) {
        return false;
      } else {
        return a < b;
      }
    } else {
      return evam[a] < evam[b];
    }
  }
};
int main() {
  ios::sync_with_stdio(false);
  int t;
  set<int, cmp> st;
  cin >> n;
  if (n & 1) {
    for (int i = 1; i <= n; i++) {
      cin >> t;
      if (t) {
        g[t].push_back(i);
        cnt[t]++;
        g[i].push_back(t);
        cnt[i]++;
      }
    }
    cout << "YES" << endl;
    t = dfs(1);
    for (int i = 1; i <= n; i++) {
      if (!evam[i]) {
        st.insert(i);
      }
    }
    while (!st.empty()) {
      t = *st.begin();
      st.erase(st.begin());
      cout << t << endl;
      del[t] = 1;
      for (int i = 0; i < g[t].size(); i++) {
        if (!del[g[t][i]]) {
          cnt[g[t][i]]--;
          evam[g[t][i]]--;
          if (!evam[g[t][i]]) {
            st.insert(g[t][i]);
          }
        }
      }
    }
  } else {
    cout << "NO" << endl;
  }
  return 0;
}