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;
const int MaxN = 2e5 + 5;
int N, Root;
int Size[MaxN];
bool Vis[MaxN];
vector<int> Son[MaxN];
namespace Input {
const int L = 1 << 20;
char *s, *t, c, buf[L];
char gc() {
  if (s == t) {
    t = (s = buf) + fread(buf, 1, L, stdin);
    if (s == t) return EOF;
  }
  return *s++;
}
void gi(int &x) {
  x = 0;
  while (c = gc(), c < '0' || c > '9')
    ;
  while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = gc();
}
}  // namespace Input
using Input::gi;
void Del(int u) {
  Vis[u] = true;
  printf("%d\n", u);
  int i;
  for (i = 0; i < Son[u].size(); i++)
    if (!Vis[Son[u][i]]) Del(Son[u][i]);
}
void DFS(int u) {
  int i;
  Size[u] = 1;
  for (i = 0; i < Son[u].size(); i++) {
    DFS(Son[u][i]);
    Size[u] += Size[Son[u][i]];
  }
  if (!(Size[u] & 1)) Del(u);
}
int main() {
  int i, fa;
  gi(N);
  if (!(N & 1)) {
    puts("NO");
    return 0;
  }
  puts("YES");
  for (i = 1; i <= N; i++) {
    gi(fa);
    if (fa)
      Son[fa].push_back(i);
    else
      Root = i;
  }
  DFS(Root);
  Del(Root);
  return 0;
}