package main

import (
	"bufio"
	"io"
	"os"
	"strconv"
)

type Edge struct {
	u, v int
}

var data []byte
var idx int

func nextInt() int {
	n := len(data)
	for idx < n && ((data[idx] < '0' || data[idx] > '9') && data[idx] != '-') {
		idx++
	}
	sign := 1
	if idx < n && data[idx] == '-' {
		sign = -1
		idx++
	}
	val := 0
	for idx < n && data[idx] >= '0' && data[idx] <= '9' {
		val = val*10 + int(data[idx]-'0')
		idx++
	}
	return sign * val
}

func isNeighbor(u, v int, adj [][]int) bool {
	for _, x := range adj[u] {
		if x == v {
			return true
		}
	}
	return false
}

func commonCount(u, v int, adj [][]int) int {
	cnt := 0
	for _, x := range adj[u] {
		for _, y := range adj[v] {
			if x == y {
				cnt++
				break
			}
		}
	}
	return cnt
}

func valid(order []int, adj [][]int) bool {
	n := len(order)
	pos := make([]int, n+1)
	for i, v := range order {
		pos[v] = i
	}
	for _, v := range order {
		i := pos[v]
		a := order[(i+1)%n]
		b := order[(i+n-1)%n]
		c := order[(i+2)%n]
		d := order[(i+n-2)%n]
		if len(adj[v]) != 4 {
			return false
		}
		for _, x := range adj[v] {
			if x != a && x != b && x != c && x != d {
				return false
			}
		}
	}
	return true
}

func printOrder(w *bufio.Writer, order []int) {
	for i, v := range order {
		if i > 0 {
			w.WriteByte(' ')
		}
		w.WriteString(strconv.Itoa(v))
	}
	w.WriteByte('\n')
}

func main() {
	data, _ = io.ReadAll(os.Stdin)
	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer w.Flush()

	n := nextInt()
	adj := make([][]int, n+1)
	edges := make([]Edge, 0, 2*n)

	for i := 0; i < 2*n; i++ {
		a := nextInt()
		b := nextInt()
		if a < 1 || a > n || b < 1 || b > n || a == b {
			w.WriteString("-1\n")
			return
		}
		adj[a] = append(adj[a], b)
		adj[b] = append(adj[b], a)
		edges = append(edges, Edge{a, b})
	}

	for i := 1; i <= n; i++ {
		if len(adj[i]) != 4 {
			w.WriteString("-1\n")
			return
		}
	}

	if n == 5 {
		order := []int{1, 2, 3, 4, 5}
		if valid(order, adj) {
			printOrder(w, order)
		} else {
			w.WriteString("-1\n")
		}
		return
	}

	if n == 6 {
		partner := make([]int, n+1)
		for v := 1; v <= n; v++ {
			p := 0
			for u := 1; u <= n; u++ {
				if u == v {
					continue
				}
				if !isNeighbor(v, u, adj) {
					if p != 0 {
						w.WriteString("-1\n")
						return
					}
					p = u
				}
			}
			if p == 0 {
				w.WriteString("-1\n")
				return
			}
			partner[v] = p
		}
		for v := 1; v <= n; v++ {
			if partner[partner[v]] != v {
				w.WriteString("-1\n")
				return
			}
		}
		used := make([]bool, n+1)
		order := make([]int, 0, n)
		tail := make([]int, 0, 3)
		for v := 1; v <= n; v++ {
			if !used[v] {
				p := partner[v]
				used[v], used[p] = true, true
				order = append(order, v)
				tail = append(tail, p)
			}
		}
		order = append(order, tail...)
		if valid(order, adj) {
			printOrder(w, order)
		} else {
			w.WriteString("-1\n")
		}
		return
	}

	cycleAdj := make([][]int, n+1)
	for _, e := range edges {
		c := commonCount(e.u, e.v, adj)
		if c == 2 {
			cycleAdj[e.u] = append(cycleAdj[e.u], e.v)
			cycleAdj[e.v] = append(cycleAdj[e.v], e.u)
		} else if c != 1 {
			w.WriteString("-1\n")
			return
		}
	}

	for i := 1; i <= n; i++ {
		if len(cycleAdj[i]) != 2 {
			w.WriteString("-1\n")
			return
		}
	}

	start := 1
	visited := make([]bool, n+1)
	order := make([]int, 1, n)
	order[0] = start
	visited[start] = true
	prev, cur := 0, start

	for {
		var nxt int
		if prev == 0 || cycleAdj[cur][0] != prev {
			nxt = cycleAdj[cur][0]
		} else {
			nxt = cycleAdj[cur][1]
		}
		if nxt == start {
			if len(order) != n {
				w.WriteString("-1\n")
				return
			}
			break
		}
		if visited[nxt] {
			w.WriteString("-1\n")
			return
		}
		visited[nxt] = true
		order = append(order, nxt)
		prev, cur = cur, nxt
	}

	if !valid(order, adj) {
		w.WriteString("-1\n")
		return
	}

	printOrder(w, order)
}