package timus;

import java.util.*;

/**

* Created by sherxon on 2016-11-26.

*/

public class GenealogicalTree {

public static void main(String[] args) {

Scanner in =new Scanner(System.in);

int n=in.nextInt();

G g= new G();

Set<Integer> roots= new TreeSet<>((a, b)->b.compareTo(a));

for (int i = 1; i <=n; i++) {

g.addVertex(i);

roots.add(i);

}

int child=-1;

for (int i = 1; i <=n;) {

child=in.nextInt();

if(child==0){

i++;

}else{

roots.remove(Integer.valueOf(child));

g.addEdge(i,child, 0);

}

}

g.reset();

Stack<Integer> stack= new Stack<>();

for (Integer root : roots) {

topSort(g, root, stack);

}

while (!stack.empty())

System.out.print(stack.pop() + " ");

System.out.println();

}

public static void topSort(G graph, Integer start, Stack<Integer> list){

G.V vertex=graph.vertices.get(start);

vertex.visited=true;

if(vertex.edges.size()>0){

for (G.E edge : vertex.edges) {

if(!edge.to.visited) {

topSort(graph, edge.to.label, list);

}

}

}

list.add(vertex.label);

}

private static class G{

private Map<Integer, V> vertices= new LinkedHashMap<>();

public void addVertex(Integer v){

V newV= new V(v);

vertices.putIfAbsent(v, newV);

}

public void addEdge(Integer from, Integer to, int weight){

V fromV=vertices.get(from);

V toV=vertices.get(to);

E e= new E(fromV, toV, weight);

fromV.edges.add(e); // directed graph

}

public void reset() {

vertices.values().stream().forEach(s->s.visited=false);

}

public class V implements Comparable{

List<E> edges= new ArrayList<>();

private Integer label;

int distance;

V parent;

boolean visited;

public V(Integer label) {

this.label = label;

this.distance=0;

}

@Override

public int compareTo(Object o) {

return this.distance - ((V)o).distance;

}

}

private class E{

V from;

V to;

int weight;

public E(V from, V to, int weight) {

this.from = from;

this.to = to;

this.weight = weight;

}

}

}

}