from collections import defaultdict
import heapq

N, M = map(int, input().split())
edges = defaultdict(dict)
for i in range(M):
    a, b, d = map(int, input().split())
    edges[a][b] = d
    edges[b][a] = d

def dijkstra(edges, initial, final):
    heap = [(0, initial, None)]
    final_distances = {}
    successors = {}

    while True:
        if not heap:
            return None
        if len(successors) == len(edges):
            return successors
        d_v, v, succ = heapq.heappop(heap)
        if v in final_distances:
            continue
        final_distances[v] = d_v
        successors[v] = succ
        if v == final:
            return successors

        for w, d in edges[v].items():
            if w in final_distances:
                continue
            heapq.heappush(
                heap,
                (
                    d_v + d,
                    w,
                    v
                )
            )

successors = dijkstra(edges, initial=1, final=None)
if successors is None:
    print("impossible")
    quit()

for v, w in successors.items():
    try:
        del edges[v][w]
    except KeyError:
        pass

predecessors = dijkstra(edges, initial=0, final=1)
if predecessors is None:
    print("impossible")
    quit()

node = 1
path = [node]
while True:
    node = predecessors[node]
    path.append(node)
    if node == 0:
        break
path.reverse()

print(len(path), *path)