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 JAVA):

Solution:


import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Stack;

public class P963B {

static Scanner in = new Scanner(System.in);
	
	static HashMap<Integer, ArrayList<Integer>> g;
	
	static int n;
	
	static boolean ans=true;
	
	static Stack<Integer> st = new Stack<>();
	
	static StringBuilder sb = new StringBuilder();
	
	static int[] size;
	
	public static void main(String[] args) {
		n = in.nextInt();
		g = new HashMap<>();
		
		size = new int[n];
		
		for(int i=0; i<n; i++) g.put(i, new ArrayList<>());
		
		int root=0;
		
		for(int i=0; i<n; i++) {
			int u = i;
			int v = in.nextInt()-1;
			if (v==-1) {
				root=i;
				continue;
			}
			g.get(u).add(v);
			g.get(v).add(u);
			
		}

		dfs(root, -1, 0);
		
		System.out.println(st.isEmpty()?"YES":"NO");
		
		if (st.isEmpty())
			System.out.println(sb);
		
		
	}
	
	public static boolean dfs(int v, int pv, int d) {
		
		long degree=pv==-1?0:1;
		
		size[v]=1;
		
		for(int u: g.get(v)) {
			if (u==pv) continue;
			
			boolean del=dfs(u, v, d+1);
			
			if (!del) size[v]+=size[u];
			
			if (!del) degree++;
			
		}
		
		if (degree%2!=0) {
			st.push(v);
		} else {
			//deleted then delete all its children
			sb.append((v+1)+"\n");
			int count=0;
			while(!st.isEmpty()) {
				sb.append((st.pop()+1)+"\n");
				count++;
				if (count==size[v]-1) break;
			}
		}
		
		return degree%2==0;
	}

}