#!/usr/bin/python3

import sys
input = sys.stdin.readline

n,m = [int(x) for x in input().split()]

graph = [[] for _ in range(n)]
for _ in range(m):
    u,v = [int(x) - 1 for x in input().split()]
    graph[u].append(v)
    graph[v].append(u)

graph_set = [set(g) for g in graph]

def typer(a,b):
    """ check if node a has an edge to node b """
    return a in graph_set[b]

def check(a,b,c,d):
    """ Check that a,b,c,d is locally a valid ski cycle sequence """
    return not(typer(a,b) == typer(c,d) != typer(b,c))

left_stack = []
right_stack = []
a = 0
b = 1
c = None

for node in range(2, n):
    if a is None:
        assert not left_stack
        right_stack.append(c)
        right_stack.append(b)

        right_stack.reverse()
        left_stack, right_stack = right_stack, left_stack
        b = left_stack.pop()
        a = left_stack.pop()
        c = None
    
    if c is None:
        c = node
        if typer(a,b) == typer(b,c):
            left_stack.append(a)
            a,b,c = b,c,None
        continue

    if check(a,node,b,c):
        b,c,d = node,b,c

        if typer(b,c) == typer(c,d):
            right_stack.append(d)
        else:
            left_stack.append(a)
            a,b,c = b,c,d
        
        if typer(a,b) == typer(b,c):
            right_stack.append(c)
            if left_stack:
                a,b,c = left_stack.pop(),a,b
            else:
                a,b,c = None,a,b
    
    else:
        c,d = node,c 

        if typer(a,b) == typer(b,c):
            left_stack.append(a)
            a,b,c = b,c,d
        else:
            right_stack.append(d)
        
        if typer(a,b) == typer(b,c):
            left_stack.append(a)
            if right_stack:
                a,b,c = b,c,right_stack.pop()
            else:
                a,b,c = b,c,None

for x in a,b,c:
    if x is not None:
        left_stack.append(x)

ans = left_stack + right_stack[::-1]

CHECK_OUTPUT = False
if CHECK_OUTPUT:
    count = 0
    for i in range(n - 2):
        count += typer(ans[i], ans[i + 1]) != typer(ans[i + 1], ans[i + 2])

    assert count <= 1
    assert ans[0] == 0
    assert len(ans) == n
    assert len(set(ans)) == n

print(*[a + 1 for a in ans])