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.ArrayList;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.Stack;

public class Main {
public static void dfs(LinkedList<Integer>[]adj, int node, int dist, boolean[]vis, Stack<Integer> l,Stack<Integer>S){
    l.push(node);
    if(l.isEmpty()){
        return;
    }
    if(node==dist){
        while (l.empty()!=true){
            S.push(l.pop());
        }
        return;
    }
    vis[node]=true;
    if(!adj[node].isEmpty()){
        if(l.isEmpty()){
            return;
        }
        for(int i=0;i<adj[node].size();i++){
            if(l.isEmpty()){
                return;
            }
            if(vis[adj[node].get(i)]==false){
                dfs(adj,adj[node].get(i),dist,vis,l,S);
            }
        }
    }
    if(!l.isEmpty()){
    l.pop();}
    else {
        return;
    }

    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] a = new int[n];
        LinkedList<Integer>[] adj = new LinkedList[n + 1];
        for (int i = 1; i < n; i++) {
            a[i] = in.nextInt();
        }
        int n2=-1;
        int f=1;
        Stack<Integer>s1=new Stack();
        s1.push(n);
        while (n!=1){
            n=a[n-1];
            s1.push(n);
        }
        int size=s1.size();
        for(int i=0;i<size;i++){
            System.out.print(s1.pop()+" ");
        }
        /*
        for (int i = 0; i < n + 1; i++) {
            adj[i] = new LinkedList();
        }
        if (a[a.length - 1] == 1) {
            System.out.println(1 + " " + n);
        } else {
            for (int i = 1; i < n; i++) {
                int x = a[i];
                adj[i + 1].add(x);
                adj[x].add(i + 1);
            }
                Stack<Integer> l = new Stack();
                Stack<Integer> s = new Stack();
                boolean[] vis = new boolean[n + 1];
                dfs(adj, 1, n, vis, l, s);
                int size = s.size();
                for (int i = 0; i < size; i++) {
                    System.out.print(s.pop() + " ");

            }
        }*/
    }
}
