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>
import java.io.*;
import java.lang.*;
import java.math.*;
import java.util.*;

public class D
{
     static StringBuilder sb = new StringBuilder();
     static ArrayList<HashSet<Integer>> g;
     static int[] depth;
     static boolean[] d;
     static int[] dc;
	 public static void main(String[] args) {
        FastReader fr = new FastReader();
        int n = fr.nextInt();
        if(n%2 == 0) System.out.println("NO");
        else {
            g = new ArrayList<>();
            for(int i=0; i<n; i++){
                g.add(new HashSet<>());
            }
            int root = 0;
            for(int i=0; i<n; i++){
                int v = fr.nextInt();
                if(v == 0) {
                    root = i;
                }else{
                    g.get(i).add(v-1);
                    g.get(v-1).add(i);
                }
            }
            depth = new int[n];
            d = new boolean[n];
            dc = new int[n];
            sb.append("YES\n");
            depth[root] = 1;
            dfs(root);
            System.out.print(sb);
        }
    }
    static void dfs(int u){
        for(int v : g.get(u)){
            if(depth[v] == 0) {
                depth[v] = depth[u]+1;
                dfs(v);
            }
        }
        if((g.get(u).size()-dc[u]) % 2 == 0) {
            for(int v : g.get(u)){
                if(depth[v] == depth[u] - 1 && !d[v]) dc[v]++;
            }
            destroy(u);
        }
    }
    static void destroy(int u){
        d[u] = true;
        sb.append((u+1) + "\n");
        for(int v : g.get(u)){
            if(depth[v] == depth[u] + 1 && !d[v]) destroy(v);
        }
    }
}

class FastReader{
	BufferedReader br;
	StringTokenizer st;

	FastReader(){
		br = new BufferedReader(new InputStreamReader(System.in));
	}

	String next(){
		while(st==null || !st.hasMoreTokens()){
			try{
				st = new StringTokenizer(br.readLine());
			}catch(IOException e){
				e.printStackTrace();
			}
		}
		return st.nextToken();
	}

	int nextInt(){
		return Integer.parseInt(next());
	}

	long nextLong(){
		return Long.parseLong(next());
	}

	double nextDouble(){
		return Double.parseDouble(next());
	}

	String nextLine(){
		String str = "";
		try{
			str = br.readLine();
		}catch(IOException e){
			e.printStackTrace();
		}
		return str;
	}
}
