Once upon a time there was only one router in the well-known company Bmail. Years went by and over time new routers were purchased. Every time they bought a new router, they connected it to one of the routers bought before it. You are given the values p_i — the index of the router to which the i-th router was connected after being purchased (p_i < i).

There are n routers in Boogle in total now. Print the sequence of routers on the path from the first to the n-th router.

Input

The first line contains integer number n (2 ≤ n ≤ 200000) — the number of the routers. The following line contains n-1 integers p_2, p_3, ..., p_n (1 ≤ p_i < i), where p_i is equal to index of the router to which the i-th was connected after purchase.

Output

Print the path from the 1-st to the n-th router. It starts with 1 and ends with n. All the elements in the path should be distinct.

Examples

Input

8
1 1 2 2 3 2 5


Output

1 2 5 8 

Input

6
1 2 3 4 5


Output

1 2 3 4 5 6 

Input

7
1 1 2 3 4 3


Output

1 3 7 
import java.util.*;

public class Solution{
	public static void main(String[] args){
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		int[] routers = new int[n];
		routers[0] = 1;
		int count = 1;
		while(count<n){
			routers[count] = s.nextInt();
			count++;
		}
		Node root = buildTree(routers);
		LinkedList<Integer> path = dfs(root, n);
		for(Integer p : path){
			System.out.print(p+" ");
		}
		System.out.println();
	}
	public static Node buildTree(int[] routers){
		HashMap<Integer, Node> nodes = new HashMap<Integer, Node>();
		Node root = new Node(null, routers[0]);
		nodes.put(root.value, root);
		for(int i=1; i<routers.length; i++){
			Node parent = nodes.get(routers[i]);
			Node cur = new Node(parent, i+1);
			nodes.put(cur.value, cur);
			parent.children.add(cur);
		}
		return root;
	}

	public static LinkedList<Integer> dfs(Node root, int n){
		if(root == null){
			return null;
		}
		LinkedList<Node> stack = new LinkedList<Node>();
		stack.push(root);

		while(!stack.isEmpty()){
			Node cur = stack.pop();
			if(cur.value == n){
				// found, return path
				LinkedList<Integer> pathNumbers = new LinkedList<Integer>();
				Node pathNode = cur;
				while(pathNode != null){
					pathNumbers.addFirst(pathNode.value);
					pathNode = pathNode.parent;
				}
				return pathNumbers;
			}
			stack.addAll(stack.size(), cur.children);
		}
		return null;
	}
}

class Node{
	LinkedList<Node> children;
	Node parent;
	int value;
	public Node(Node parent, int value){
		this.children = new LinkedList<Node>();
		this.parent = parent;
		this.value = value;
	}
}