package main

import (
	"bufio"
	"fmt"
	"os"
)

var (
	adj       [105][105]bool
	origGraph [105][]int
	visited   [105]bool
	q         [105]int
	n, m      int
)

func isValid(curr, u, remEdges int) bool {
	if remEdges <= 1 {
		return true
	}
	adj[curr][u] = false
	adj[u][curr] = false

	for i := 1; i <= n; i++ {
		visited[i] = false
	}

	head, tail := 0, 0
	q[tail] = u
	tail++
	visited[u] = true

	edgesCount := 0

	for head < tail {
		v := q[head]
		head++

		for _, nxt := range origGraph[v] {
			if adj[v][nxt] {
				edgesCount++
				if !visited[nxt] {
					visited[nxt] = true
					q[tail] = nxt
					tail++
				}
			}
		}
	}

	adj[curr][u] = true
	adj[u][curr] = true

	return edgesCount == (remEdges-1)*2
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	fmt.Fscan(in, &n, &m)

	P := make([]int, m+1)
	for i := 0; i <= m; i++ {
		fmt.Fscan(in, &P[i])
	}

	var hasEdge [105][105]bool
	for i := 0; i < m; i++ {
		u, v := P[i], P[i+1]
		if !hasEdge[u][v] {
			hasEdge[u][v] = true
			hasEdge[v][u] = true
			origGraph[u] = append(origGraph[u], v)
			origGraph[v] = append(origGraph[v], u)
		}
	}

	branchIdx := -1
	branchVal := -1

	for i := m; i >= 1; i-- {
		curr := P[i-1]
		u := P[i]
		adj[curr][u] = true
		adj[u][curr] = true

		remEdges := m - i + 1

		for w := P[i] + 1; w <= n; w++ {
			if adj[curr][w] {
				if isValid(curr, w, remEdges) {
					branchIdx = i
					branchVal = w
					break
				}
			}
		}
		if branchIdx != -1 {
			break
		}
	}

	if branchIdx == -1 {
		fmt.Fprintln(out, "No solution")
		return
	}

	ans := make([]int, m+1)
	copy(ans, P[:branchIdx])
	ans[branchIdx] = branchVal

	curr := P[branchIdx-1]
	adj[curr][branchVal] = false
	adj[branchVal][curr] = false

	for j := branchIdx + 1; j <= m; j++ {
		curr = ans[j-1]
		remEdges := m - j + 1
		found := false
		for w := 1; w <= n; w++ {
			if adj[curr][w] {
				if isValid(curr, w, remEdges) {
					ans[j] = w
					adj[curr][w] = false
					adj[w][curr] = false
					found = true
					break
				}
			}
		}
		if !found {
			fmt.Fprintln(out, "No solution")
			return
		}
	}

	for i := 0; i <= m; i++ {
		if i > 0 {
			fmt.Fprint(out, " ")
		}
		fmt.Fprint(out, ans[i])
	}
	fmt.Fprintln(out)
}