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.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Stack;
 
public class P963B {
	private static Scanner in;

    private static int n;
    private static HashMap<Integer, ArrayList<Integer>> g;
    private static int[] size;

    private static Stack<Integer> children;
    private static StringBuilder sb;

	public static void main(String[] args) {
		in = new Scanner(System.in);
		n = in.nextInt();

        g = new HashMap<>();
        for(int i=0; i<n; i++) {
            g.put(i, new ArrayList<Integer>());
        }
        
        for(int i=0; i<n; i++) {
        	int p = in.nextInt();
        	if (p!=0) {
        		g.get(p-1).add(i);
        		g.get(i).add(p-1);
        	}
        }

        size = new int[n];

        children = new Stack<>();

        sb = new StringBuilder();

        dfs(0, -1);

        if (!children.isEmpty()) {
            System.out.println("NO");
        } else{
            System.out.println("YES");
            System.out.println(sb.toString().trim());
        }

	}

    public static boolean dfs(int u, int p) {

        size[u] = 1;

        int degree = (p==-1?0:1);

        for(int v: g.get(u)) {
            if (v==p) continue;
            
            boolean deleted = dfs(v, u);

            if (!deleted) {
                degree++;
                size[u] += size[v];
            }
        }

        if (degree%2==0) {
            sb.append((u+1)+"\n");
            for(int j=0; j<size[u]-1; j++) {
                sb.append((children.pop()+1)+"\n");
            }
        } else {
            children.push(u);
        }


        return degree%2==0;
    }

    
 
}