CodeForces-1057A.py

from collections import *
from math import *
from heapq import *
from itertools import *
from queue import *
from cmath import *
from random import *
from functools import *
from time import *
import sys
import os
import decimal

def INPUTS():
   #n = int(sys.stdin.readline().strip())
   #arrary = [int(sys.stdin.readline().strip()) for _ in range(n)]
   # u, v, w = map(int,input().split())
   # n, k = map(int, input().split())
   t = int(input())
   #s = input().strip()
   #a,b = input().split()
   # L = sorted(list(map(int, input().split())))
   H = list(map(int,input().split()))
   return t,H


def find_router_path(n, parents):
    parent = [0] * (n + 1)
    for i in range(2, n + 1):
        parent[i] = parents[i - 2]
    
    path = []
   
    current = n
    while current != 0:
        path.append(current)
        current = parent[current]
    path.reverse()
    return " ".join(map(str, path))


def solution():
    n, parents = INPUTS()
    result = find_router_path(n, parents)
    print(result)
 


def main():
   #test_cases = int(input())
   # for T in range(test_cases):

   #    solution()
      #print(f'Case{T+1}:{solution()}')
      
   solution()
   
   
   
def MODULAR_EXPONENTIATION(base, exp, mod):
    return __builtins__.pow(base, exp, mod)



def AND(arr):
    result = arr[0]
    for num in arr[1:]:
        result &= num
    return result
 
def OR(arr):
    result = arr[0]
    for num in arr[1:]:
        result |= num
    return result
 
 
def XOR(arr):
    result = arr[0]
    for num in arr[1:]:
        result ^= num
    return result



def Seive(LIMIT):
   T = int(sqrt(abs(LIMIT)))+1
   primes = [True]*(T+1)
   primes[0] = primes[1] = False
   for i in range(2, T+1):
      if primes[i]:
         for q in range(i+i, LIMIT+1, i):
               primes[q] = False
   return [p for p in range(LIMIT) if primes[p]]




def prime(n):
   factors = Seive(n)
   possible = True
   for x in factors:
      if n % x == 0:
         possible = False
         break
   return possible




def PRIME_FACTORS(n):
    factors = [1] 
    if n == 0:
       return
    while n % 2 == 0:
        factors.append(2)
        n //= 2
    for i in range(3, int(n**0.5) + 1, 2):
        while n % i == 0:
            factors.append(i)
            n //= i
    if n > 2:
        factors.append(n)

    return factors





def SUBARRAYS(arr):
    n = len(arr)
    subarrays = []
    for start in range(n):
        for end in range(start, n):
            subarrays.append(arr[start:end + 1])
    return subarrays





def SUBSEQUENCES(arr):
    n = len(arr)
    subsequences = []
    for i in range(1 << n):  
        subseq = []
        for j in range(n):
            if i & (1 << j):  
                subseq.append(arr[j])
        subsequences.append(subseq)
    return subsequences



def BINARY_SEARCH(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1
 
 
 

def TERNARY_SEARCH(f, left, right, precision=1e-5):
    while right - left > precision:
        mid1 = left + (right - left) / 3
        mid2 = right - (right - left) / 3

        if f(mid1) < f(mid2):
            left = mid1
        else:
            right = mid2

    return (left + right) / 2  



def LOWER_BOUND(arr, target):
    left, right = 0, len(arr)
    while left < right:
        mid = (left + right) // 2
        if arr[mid] < target:
            left = mid + 1
        else:
            right = mid
    return left if left < len(arr) else -1 
 
 
 
def UPPER_BOUND(arr, target):
   left, right = 0, len(arr)
   while left < right:
      mid = (left + right) // 2
      if arr[mid] <= target:
         left = mid + 1
      else:
         right = mid
   return left if left < len(arr) else -1  




def COUNT_IN_RANGE(arr, l, r):
    return UPPER_BOUND(arr, r) - LOWER_BOUND(arr, l)




def SEARCH_FOR_ANSWER(arr, condition, left, right, precision=1e-5):
    while right - left > precision:
        mid = (left + right) / 2
        if condition(mid):  # Problem-specific condition
            left = mid
        else:
            right = mid
    return left  # Or right, based on what’s needed



def BFS(graph, start):
   visited = set()
   queue = deque([start])
   result = []

   while queue:
      node = queue.popleft()
      if node not in visited:
         visited.add(node)
         result.append(node)
         for neighbor in graph[node]:
               if neighbor not in visited:
                  queue.append(neighbor)

   return result






def DFS(graph, start):
   visited = set()
   stack = [start]
   result = []

   while stack:
      node = stack.pop()
      if node not in visited:
         visited.add(node)
         result.append(node)
         for neighbor in reversed(graph[node]):
               if neighbor not in visited:
                  stack.append(neighbor)

   return result






def TREE_EDGE_LIST(n, edges):
   tree = {i: [] for i in range(1, n + 1)}
   for u, v in edges:
      tree[u].append(v)
      tree[v].append(u) 
   return tree





def INPUTS_TREE_EDGE_LIST():
   n, m = map(int, input().split())
   edges = [tuple(map(int, input().split())) for _ in range(m)]
   graph = TREE_EDGE_LIST(n, edges) 
   print("Undirected graph from edge list:", graph)






def TREE_ADJ_LIST(adj_list):
   tree = {}
   for node, neighbors in adj_list.items():
      tree[node] = neighbors
   return tree






def GRAPH_ADJ_MATRIX(adj_matrix):
   graph = {}
   n = len(adj_matrix)
   for i in range(n):
      graph[i] = []
      for j in range(n):
         if adj_matrix[i][j] != 0:
               graph[i].append(j)
   return graph






def INPUTS_GRAPH_ADJ_MATRIX():
   n = int(input())
   adj_matrix = [list(map(int, input().split())) for _ in range(n)]
   graph = GRAPH_ADJ_MATRIX(adj_matrix)
   print("Graph from adjacency matrix:", graph)







def GRAPH_INC_MATRIX(inc_matrix):
   graph = {}
   num_vertices = len(inc_matrix)
   num_edges = len(inc_matrix[0])

   for i in range(num_vertices):
      graph[i] = []

   for j in range(num_edges):
      vertices = []
      for i in range(num_vertices):
         if inc_matrix[i][j] == 1:
               vertices.append(i)
      if len(vertices) == 2:
         u, v = vertices
         graph[u].append(v)
         graph[v].append(u)

   return graph







def INPUTS_GRAPH_INC_MATRIX():
   n, m = map(int, input().split())
   inc_matrix = [list(map(int, input().split())) for _ in range(n)]
   graph = GRAPH_INC_MATRIX(inc_matrix)
   print("Graph from incidence matrix:", graph)






def GRAPH_WEIGHTED_EDGE_LIST(n, weighted_edges):
   graph = {i: [] for i in range(1, n + 1)}
   for u, v, weight in weighted_edges:
      graph[u].append((v, weight))
      graph[v].append((u, weight))
   return graph






def INPUTS_WEIGHTED_EDGE_LIST():
   n, m = map(int, input().split())
   weighted_edges = [tuple(map(int, input().split())) for _ in range(m)]
   graph = GRAPH_WEIGHTED_EDGE_LIST(n, weighted_edges)
   print("Weighted graph from edge list:", graph)






def GRAPH_UNDIRECTED_EDGE_LIST(n, edges):
   graph = {i: [] for i in range(1, n + 1)}
   for u, v in edges:
      graph[u].append(v)
      graph[v].append(u)
   return graph





def INPUTS_GRAPH_EDGE_LIST(directed=True):
   n, m = map(int, input().split())
   edges = [tuple(map(int, input().split())) for _ in range(m)]
   if directed:
      graph = GRAPH_DIRECTED_EDGE_LIST(n, edges)
      print("Directed graph from edge list:", graph)
   else:
      graph = GRAPH_UNDIRECTED_EDGE_LIST(n, edges)
      print("Undirected graph from edge list:", graph)





def GRAPH_DIRECTED_EDGE_LIST(n, edges):
   graph = {i: [] for i in range(1, n + 1)}
   for u, v in edges:
      graph[u].append(v)
   return graph





def DIJKSTRA_ADJ_LIST(graph, start):
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]
    
    while priority_queue:
        current_distance, current_node = heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node]:
            distance = current_distance + weight

            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heappush(priority_queue, (distance, neighbor))

    return distances

 
 
 
 
 
 
def DIJAKSTRA_ADJ_MATRIX(matrix, start):
   n = len(matrix)
   distances = [float('inf')] * n
   distances[start] = 0
   priority_queue = [(0, start)]

   while priority_queue:
      current_distance, u = heappop(priority_queue)

      if current_distance > distances[u]:
         continue

      for v in range(n):
         if matrix[u][v] != float('inf'): 
               distance = current_distance + matrix[u][v]
               if distance < distances[v]:
                  distances[v] = distance
                  heappush(priority_queue, (distance, v))

   return distances






def DIJAKSTRA_EDGE_LIST(edges, start, num_nodes):
    graph = defaultdict(list)
    for u, v, w in edges:
        graph[u].append((v, w))

    distances = {node: float('inf') for node in range(num_nodes)}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, u = heappop(priority_queue)

        if current_distance > distances[u]:
            continue

        for v, weight in graph[u]:
            distance = current_distance + weight
            if distance < distances[v]:
                distances[v] = distance
                heappush(priority_queue, (distance, v))

    return distances






def SECOND_SHORTEST_PATH_EDGE_LIST(n, edges, start, end):
    graph = defaultdict(list)
    for u, v, w in edges:
        graph[u].append((v, w))
        graph[v].append((u, w))  
    distances = [[float('inf'), float('inf')] for _ in range(n)]
    distances[start][0] = 0  

    pq = [(0, start, 0)]  
    while pq:
        current_distance, u, path_type = heappop(pq)

        for v, weight in graph[u]:
            new_distance = current_distance + weight
            if new_distance < distances[v][0]:
                distances[v][1] = distances[v][0] 
                distances[v][0] = new_distance
                heappush(pq, (new_distance, v, 0))

            elif distances[v][0] < new_distance < distances[v][1]:
                distances[v][1] = new_distance
                heappush(pq, (new_distance, v, 1))

    return distances[end][1] if distances[end][1] < float('inf') else -1
 
 
 
 
 
def SECOND_SHORTEST_PATH_ADJ_MATRIX(matrix, start, end):
   n = len(matrix)
   distances = [[float('inf'), float('inf')] for _ in range(n)]
   distances[start][0] = 0
   pq = [(0, start, 0)]

   while pq:
      dist, u, path_type = heappop(pq)
      for v in range(n):
         weight = matrix[u][v]
         if weight > 0:  
               new_distance = dist + weight
               if new_distance < distances[v][0]:
                  distances[v][1] = distances[v][0]
                  distances[v][0] = new_distance
                  heappush(pq, (new_distance, v, 0))
               elif distances[v][0] < new_distance < distances[v][1]:
                  distances[v][1] = new_distance
                  heappush(pq, (new_distance, v, 1))

   return distances[end][1] if distances[end][1] < float('inf') else -1

 
 
 
 
 
 
def SECOND_SHORTEST_PATH_ADJ_LIST(n, edges, start, end):
    graph = defaultdict(list)
    for u, v, w in edges:
        graph[u].append((v, w))
        graph[v].append((u, w))  
    distances = [[float('inf'), float('inf')] for _ in range(n)]
    distances[start][0] = 0
    pq = [(0, start, 0)]  

    while pq:
        dist, u, path_type = heappop(pq)
        for v, weight in graph[u]:
            new_distance = dist + weight
            if new_distance < distances[v][0]:
                distances[v][1] = distances[v][0]
                distances[v][0] = new_distance
                heappush(pq, (new_distance, v, 0))
            elif distances[v][0] < new_distance < distances[v][1]:
                distances[v][1] = new_distance
                heappush(pq, (new_distance, v, 1))

    return distances[end][1] if distances[end][1] < float('inf') else -1







def SECOND_SHORTEST_BFS_ADJ_LIST(graph, start, end):
    shortest = defaultdict(lambda: float('inf'))
    second_shortest = defaultdict(lambda: float('inf'))
    shortest[start] = 0

    queue = deque([(start, 0)])

    while queue:
        node, dist = queue.popleft()
        
        for neighbor in graph[node]:
            new_dist = dist + 1

            if new_dist < shortest[neighbor]:
                second_shortest[neighbor] = shortest[neighbor]
                shortest[neighbor] = new_dist
                queue.append((neighbor, new_dist))
            elif shortest[neighbor] < new_dist < second_shortest[neighbor]:
                second_shortest[neighbor] = new_dist
                queue.append((neighbor, new_dist))

    return second_shortest[end] if second_shortest[end] != float('inf') else -1







def SECOND_SHORTEST_PATH_BFS_ADJ_MATRIX(graph, start, end):
    n = len(graph)
    shortest = [float('inf')] * n
    second_shortest = [float('inf')] * n
    shortest[start] = 0
    queue = deque([(start, 0)])

    while queue:
        node, dist = queue.popleft()
        
        for neighbor in range(n):
            if graph[node][neighbor] == 1: 
                new_dist = dist + 1

                if new_dist < shortest[neighbor]:
                    second_shortest[neighbor] = shortest[neighbor]
                    shortest[neighbor] = new_dist
                    queue.append((neighbor, new_dist))
                elif shortest[neighbor] < new_dist < second_shortest[neighbor]:
                    second_shortest[neighbor] = new_dist
                    queue.append((neighbor, new_dist))

    return second_shortest[end] if second_shortest[end] != float('inf') else -1






def SECOND_SHORTEST_BFS_EDGE_LIST(edge_list, num_nodes, start, end):
    graph = defaultdict(list)
    for u, v in edge_list:
        graph[u].append(v)
        graph[v].append(u)

    return SECOND_SHORTEST_PATH_ADJ_LIST(graph, start, end)






def PRIM_ADJ_LIST(graph, start):
    mst_cost = 0
    visited = set()
    min_heap = [(0, start)]  

    while min_heap:
        cost, node = heappop(min_heap)

        if node in visited:
            continue

        visited.add(node)
        mst_cost += cost

        for neighbor, weight in graph[node]:
            if neighbor not in visited:
                heappush(min_heap, (weight, neighbor))

    return mst_cost








def PRIM_ADJ_MATRIX(matrix, start):
    n = len(matrix)
    mst_cost = 0
    visited = [False] * n
    min_edge = [(float('inf'), start)] 
    min_edge[start] = (0, start)

    for _ in range(n):
        cost, node = min_edge[0]
        min_edge = min_edge[1:]

        if visited[node]:
            continue
        
        visited[node] = True
        mst_cost += cost

        for neighbor in range(n):
            if matrix[node][neighbor] != float('inf') and not visited[neighbor]:
                min_edge.append((matrix[node][neighbor], neighbor))

    return mst_cost






def PRIM_EDGE_LIST(edges, num_nodes):
    graph = defaultdict(list)
    for u, v, w in edges:
        graph[u].append((v, w))
        graph[v].append((u, w))

    return PRIM_ADJ_LIST(graph, 0) 






def BELLMAN_FORD_ADJ_LIST(graph, num_nodes, start):
    distances = [float('inf')] * num_nodes
    distances[start] = 0

    for _ in range(num_nodes - 1):
        for u in range(num_nodes):
            for v, weight in graph[u]:
                if distances[u] != float('inf') and distances[u] + weight < distances[v]:
                    distances[v] = distances[u] + weight

    for u in range(num_nodes):
        for v, weight in graph[u]:
            if distances[u] != float('inf') and distances[u] + weight < distances[v]:
                raise ValueError("Graph contains a negative-weight cycle")

    return distances



def BELLMAN_FORD_ADJ_MATRIX(matrix, num_nodes, start):
    distances = [float('inf')] * num_nodes
    distances[start] = 0

    for _ in range(num_nodes - 1):
        for u in range(num_nodes):
            for v in range(num_nodes):
                if matrix[u][v] != float('inf') and distances[u] != float('inf'):
                    if distances[u] + matrix[u][v] < distances[v]:
                        distances[v] = distances[u] + matrix[u][v]

    for u in range(num_nodes):
        for v in range(num_nodes):
            if matrix[u][v] != float('inf') and distances[u] != float('inf'):
                if distances[u] + matrix[u][v] < distances[v]:
                    raise ValueError("Graph contains a negative-weight cycle")

    return distances






def BELLMAN_FORD_EDGE_LIST(edges, num_nodes, start):
    distances = [float('inf')] * num_nodes
    distances[start] = 0

    for _ in range(num_nodes - 1):
        for u, v, weight in edges:
            if distances[u] != float('inf') and distances[u] + weight < distances[v]:
                distances[v] = distances[u] + weight

    for u, v, weight in edges:
        if distances[u] != float('inf') and distances[u] + weight < distances[v]:
            raise ValueError("Graph contains a negative-weight cycle")

    return distances







def KMP_SEARCH(text, pattern):
    m = len(pattern)
    n = len(text)

    lps = [0] * m
    j = 0  
    compute_LPS(pattern, lps)

    i = 0  
    while i < n:
        if pattern[j] == text[i]:
            i += 1
            j += 1

        if j == m:  
            print(f"Pattern found at index {i - j}")
            j = lps[j - 1]  
        elif i < n and pattern[j] != text[i]:
            if j != 0:
                j = lps[j - 1]  
            else:
                i += 1 
                
                
                
                
                
                
                
def compute_LPS(pattern, lps):
    length = 0 
    i = 1
    lps[0] = 0  
    while i < len(pattern):
        if pattern[i] == pattern[length]:
            length += 1
            lps[i] = length
            i += 1
        else:
            if length != 0:
                length = lps[length - 1]
            else:
                lps[i] = 0
                i += 1






def TOPOLOGICAL_SORT(graph):
    visited = set()
    stack = []

    def dfs(node):
        visited.add(node)
        for neighbor in graph[node]:
            if neighbor not in visited:
                dfs(neighbor)
        stack.append(node)

    for vertex in graph:
        if vertex not in visited:
            dfs(vertex)

    return stack[::-1] 
 
 
class DSU:
    def __init__(self, n):
        self.parent = list(range(n + 1))
        self.rank = [1] * (n + 1)

    def find(self, u):
        if self.parent[u] != u:
            self.parent[u] = self.find(self.parent[u]) 
        return self.parent[u]

    def union(self, u, v):
        root_u = self.find(u)
        root_v = self.find(v)
        if root_u != root_v:
            if self.rank[root_u] < self.rank[root_v]:
                self.parent[root_u] = root_v
            elif self.rank[root_u] > self.rank[root_v]:
                self.parent[root_v] = root_u
            else:
                self.parent[root_v] = root_u
                self.rank[root_u] += 1

# n = int(input())  
# dsu = DSU(n)



def KRUSKAL(n, edges):
    dsu = DSU(n)
    mst_edges = []
    total_cost = 0

    edges.sort(key=lambda x: x[2])  
    for u, v, weight in edges:
        if dsu.find(u) != dsu.find(v):
            dsu.union(u, v)
            mst_edges.append((u, v, weight))
            total_cost += weight

    return mst_edges, total_cost





def LONGEST_INCREASING_SUBSEQUENCE(nums):
    if not nums:
        return 0

    dp = [1] * len(nums)

    for i in range(1, len(nums)):
        for j in range(i):
            if nums[i] > nums[j]:  
                dp[i] = max(dp[i], dp[j] + 1)

    return max(dp)  




def LONGEST_COMMON_SUBSEQUENCE(text1, text2):
    m, n = len(text1), len(text2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if text1[i - 1] == text2[j - 1]: 
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])

    return dp[m][n]
 
 
 
 
 
 
def EDGE_LIST_TO_MATRIX(n, edges):
   INF = float('inf')
   dist = [[INF] * n for _ in range(n)]
   for i in range(n):
      dist[i][i] = 0
   for u, v, w in edges:
      dist[u][v] = w 
   return dist






def FLOYD_WARSHALL(graph):
    n = len(graph)
    dist = [[float('inf')] * n for _ in range(n)]
    
    for i in range(n):
        for j in range(n):
            dist[i][j] = graph[i][j]
    
    for k in range(n):
        for i in range(n):
            for j in range(n):
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
    
    for i in range(n):
        if dist[i][i] < 0:
            print("Graph contains a negative weight cycle")
            return None
    
    return dist






def FIND_BCC(n, edges):
    graph = defaultdict(list)
    for u, v in edges:
        graph[u].append(v)
        graph[v].append(u)

    disc = [-1] * n       
    low = [-1] * n        
    parent = [-1] * n
    time = [0]            
    stack = []            
    bccs = []             

    def dfs(u):
        disc[u] = low[u] = time[0]
        time[0] += 1
        children = 0

        for v in graph[u]:
            if disc[v] == -1:  
                parent[v] = u
                children += 1
                stack.append((u, v)) 
                dfs(v)
                
                low[u] = min(low[u], low[v])

                if (parent[u] == -1 and children > 1) or (parent[u] != -1 and low[v] >= disc[u]):
                    bcc = []
                    while stack[-1] != (u, v):
                        bcc.append(stack.pop())
                    bcc.append(stack.pop())
                    bccs.append(bcc)

            elif v != parent[u] and disc[v] < disc[u]:  
                low[u] = min(low[u], disc[v])
                stack.append((u, v))

    for i in range(n):
        if disc[i] == -1:
            dfs(i)
            if stack:
                bcc = []
                while stack:
                    bcc.append(stack.pop())
                bccs.append(bcc)

    return bccs
 
 
 
 
 

class Dinic:
    def __init__(self, vertices):
        self.V = vertices
        self.graph = [[] for _ in range(vertices)]

    def add_edge(self, u, v, capacity):
        self.graph[u].append([v, capacity, len(self.graph[v])])
        self.graph[v].append([u, 0, len(self.graph[u]) - 1])

    def bfs(self, source, sink, level):
        for i in range(self.V):
            level[i] = -1
        level[source] = 0
        queue = deque([source])

        while queue:
            u = queue.popleft()
            for v, capacity, _ in self.graph[u]:
                if level[v] < 0 and capacity > 0:
                    level[v] = level[u] + 1
                    queue.append(v)

        return level[sink] != -1

    def dfs(self, u, flow, sink, level, start):
        if u == sink:
            return flow
        while start[u] < len(self.graph[u]):
            v, capacity, rev = self.graph[u][start[u]]
            if level[v] == level[u] + 1 and capacity > 0:
                min_flow = min(flow, capacity)
                result = self.dfs(v, min_flow, sink, level, start)
                if result > 0:
                    self.graph[u][start[u]][1] -= result
                    self.graph[v][rev][1] += result
                    return result
            start[u] += 1
        return 0

    def max_flow(self, source, sink):
        total_flow = 0
        level = [-1] * self.V
        while self.bfs(source, sink, level):
            start = [0] * self.V
            flow = self.dfs(source, float('Inf'), sink, level, start)
            while flow:
                total_flow += flow
                flow = self.dfs(source, float('Inf'), sink, level, start)
        return total_flow

#dinic = Dinic()







class SegmentTree:
    def __init__(self, data):
        self.n = len(data)
        self.tree = [0] * (2 * self.n)
        for i in range(self.n):
            self.tree[self.n + i] = data[i]
        for i in range(self.n - 1, 0, -1):
            self.tree[i] = self.tree[2 * i] + self.tree[2 * i + 1]

    def update(self, index, value):
        pos = index + self.n
        self.tree[pos] = value
        while pos > 1:
            pos //= 2
            self.tree[pos] = self.tree[2 * pos] + self.tree[2 * pos + 1]

    def range_sum(self, left, right):
        left += self.n
        right += self.n
        sum = 0
        while left < right:
            if left % 2:
                sum += self.tree[left]
                left += 1
            if right % 2:
                right -= 1
                sum += self.tree[right]
            left //= 2
            right //= 2
        return sum

#SEGMENT_TREE = SegmentTree([data])





if __name__ == '__main__':
   main()