```go
package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	var n int
	fmt.Sscan(scanner.Text(), &n)

	if n == 1 {
		fmt.Println("YES")
		fmt.Println(1)
		return
	}
	if n == 4 {
		fmt.Println("YES")
		fmt.Println(1)
		fmt.Println(3)
		fmt.Println(2)
		fmt.Println(4)
		return
	}
	if !isPrime(n) {
		fmt.Println("NO")
		return
	}
	fmt.Println("YES")

	m := n - 1
	p := make([]int, m+1)
	k := 0
	for i := 1; i <= m; i += 2 {
		p[i] = k
		k++
	}
	k = m - 1
	for i := 2; i <= m; i += 2 {
		p[i] = k
		k--
	}

	e := make([]int, m+1)
	for i := 1; i <= m; i++ {
		e[i] = p[i]
	}

	delta := make([]int, m+1)
	for k := 1; k <= m; k++ {
		prev := 0
		if k > 1 {
			prev = e[k-1]
		}
		diff := e[k] - prev
		delta[k] = (diff%m + m) % m
	}

	g := primitiveRoot(n)
	a := make([]int, m+1)
	for k := 1; k <= m; k++ {
		a[k] = modPow(g, delta[k], n)
	}
	for k := 1; k <= m; k++ {
		fmt.Println(a[k])
	}
	fmt.Println(n)
}

func isPrime(n int) bool {
	if n <= 1 {
		return false
	}
	if n <= 3 {
		return true
	}
	if n%2 == 0 || n%3 == 0 {
		return false
	}
	for i := 5; i*i <= n; i += 6 {
		if n%i == 0 || n%(i+2) == 0 {
			return false
		}
	}
	return true
}

func primitiveRoot(p int) int {
	if p == 2 {
		return 1
	}
	phi := p - 1
	factors := factorize(phi)
	for g := 2; g < p; g++ {
		isPrim := true
		for _, q := range factors {
			if modPow(g, phi/q, p) == 1 {
				isPrim = false
				break
			}
		}
		if isPrim {
			return g
		}
	}
	return -1 // Should not happen for prime p
}

func factorize(n int) []int {
	var factors []int
	for i := 2; i <= int(math.Sqrt(float64(n))); i++ {
		if n%i == 0 {
			factors = append(factors, i)
			for n%i == 0 {
				n /= i
			}
		}
	}
	if n > 1 {
		factors = append(factors, n)
	}
	return factors
}

func modPow(base, exp, mod int) int {
	result := 1
	base %= mod
	for exp > 0 {
		if exp%2 == 1 {
			result = (result * base) % mod
		}
		base = (base * base) % mod
		exp /= 2
	}
	return result
}
```