package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"os"
	"sort"
)

type Edge struct {
	u, v int
}

func isConnected(mask uint32, adj []uint32) bool {
	visited := uint32(0)
	stack := mask & -mask
	for stack != 0 {
		b := stack & -stack
		stack ^= b
		visited |= b
		idx := bits.TrailingZeros32(b)
		stack |= adj[idx] & mask &^ visited
	}
	return visited == mask
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	var n, m int
	if _, err := fmt.Fscan(in, &n, &m); err != nil {
		return
	}

	edges := make([]Edge, m)
	deg := make([]int, n)
	for i := 0; i < m; i++ {
		var u, v int
		fmt.Fscan(in, &u, &v)
		u--
		v--
		edges[i] = Edge{u, v}
		deg[u]++
		deg[v]++
	}

	if m == n*(n-1)/2 {
		fmt.Fprintln(out, 0)
		fmt.Fprintln(out)
		return
	}

	order := make([]int, n)
	for i := 0; i < n; i++ {
		order[i] = i
	}
	sort.Slice(order, func(i, j int) bool {
		if deg[order[i]] != deg[order[j]] {
			return deg[order[i]] > deg[order[j]]
		}
		return order[i] < order[j]
	})

	pos := make([]int, n)
	for i, v := range order {
		pos[v] = i
	}

	adj := make([]uint32, n)
	for _, e := range edges {
		u := pos[e.u]
		v := pos[e.v]
		adj[u] |= uint32(1) << uint(v)
		adj[v] |= uint32(1) << uint(u)
	}

	closed := make([]uint32, n)
	for i := 0; i < n; i++ {
		closed[i] = adj[i] | (uint32(1) << uint(i))
	}

	total := 1 << n
	allMask := uint32(total - 1)
	cover := make([]uint32, total)

	bestSize := n + 1
	var bestMask uint32

	for mask := 1; mask < total; mask++ {
		mu := uint32(mask)
		lsb := mu & -mu
		idx := bits.TrailingZeros32(lsb)
		prev := int(mu ^ lsb)
		cover[mask] = cover[prev] | closed[idx]

		if cover[mask] != allMask {
			continue
		}

		sz := bits.OnesCount32(mu)
		if sz >= bestSize {
			continue
		}

		if isConnected(mu, adj) {
			bestSize = sz
			bestMask = mu
			if bestSize == 1 {
				break
			}
		}
	}

	fmt.Fprintln(out, bestSize)
	first := true
	for i := 0; i < n; i++ {
		if (bestMask>>uint(i))&1 == 0 {
			continue
		}
		if !first {
			fmt.Fprint(out, " ")
		}
		first = false
		fmt.Fprint(out, order[i]+1)
	}
	fmt.Fprintln(out)
}