# DFS와 BFS

import sys
from collections import deque

input = sys.stdin.readline

def dfs(n, g, v):
    result = []
    visited = [0]*(n+1)
    stack = [v]
    
    while stack:
        w = stack.pop()
        if visited[w]:
            continue

        result.append(w)
        visited[w] = 1
        for i in range(len(g[w])-1, -1, -1):
            stack.append(g[w][i])
            
    return result

def bfs(n, g, v):
    result = []
    visited = [0]*(n+1)
    q = deque([v])
    visited[v] = 1
    
    while q:
        w = q.popleft()
        result.append(w)
        for k in g[w]:
            if not visited[k]:
                q.append(k)
                visited[k] = 1
    return result

def solution():
    n, m, v = map(int, input().rstrip().split())

    g = [[] for _ in range(n+1)]

    for _ in range(m):
        v1, v2 = map(int, input().rstrip().split())
        g[v1].append(v2)
        g[v2].append(v1)

    for i in range(1, n+1):
        g[i].sort()

    print(*dfs(n, g, v))
    print(*bfs(n, g, v))

    return


solution()

"""
걸린 시간: 34분

시간 복잡도: 간선 수에 따라 for문을 돌아보는 차이가 난다. 또한 어디 노드에 연결이 얼마나 되어 있느냐에 따라 sort의 차이도 난다.

해설: dfs는 시작 노드를 stack에 넣고 pop해가면서 인접 노드를 넣는 방식으로 구현이 가능하다.
이때, visited를 pop하고 찍음으로써 이전에 인접한 노드로 나왔더라도 한 번 더 나왔을 때 다시 넣을 수 있게 한다.
이는 깊이 탐색을 위해 뒤에서 나올수록 우선순위가 높아짐을 의미한다.
bfs는 시작 노드를 queue에 넣고 popleft 해가면서 인접 노드를 넣는 방식으로 구현이 가능하다.
이때, visited를 queue에 append 하면서 찍음으로써 이후에 인접한 노드로 또 나왔을 경우 다시 못 들어가게 한다.
이는 너비 탐색을 위해 먼저 나왔을수록 우선순위가 높음을 의미한다.
"""