```go
package main

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

type Div struct {
	val int
	mu  int
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	fmt.Fscanf(reader, "%d\n", &n)

	s, _ := reader.ReadString('\n')
	s = strings.TrimSpace(s)

	temp := n
	var primes []int
	for i := 2; i*i <= temp; i++ {
		if temp%i == 0 {
			primes = append(primes, i)
			for temp%i == 0 {
				temp /= i
			}
		}
	}
	if temp > 1 {
		primes = append(primes, temp)
	}

	N := 1
	for _, p := range primes {
		N *= p
	}

	var divs []Div
	var gen func(idx, currentVal, muOfN_over_d int)
	gen = func(idx, currentVal, muOfN_over_d int) {
		if idx == len(primes) {
			divs = append(divs, Div{val: currentVal, mu: muOfN_over_d})
			return
		}
		gen(idx+1, currentVal, -muOfN_over_d)
		gen(idx+1, currentVal*primes[idx], muOfN_over_d)
	}
	gen(0, 1, 1)

	m := n / N

	for j := 0; j < m; j++ {
		P := make([]int64, N)
		for k := 0; k < N; k++ {
			P[k] = int64(s[k*m+j] - '0')
		}

		A := P
		for _, d := range divs {
			if d.mu == -1 {
				A = mulBy(A, d.val)
			}
		}
		for _, d := range divs {
			if d.mu == 1 {
				var ok bool
				A, ok = divBy(A, d.val)
				if !ok {
					fmt.Println("NO")
					return
				}
			}
		}
	}

	fmt.Println("YES")
}

func mulBy(A []int64, d int) []int64 {
	res := make([]int64, len(A)+d)
	for i, v := range A {
		res[i+d] += v
		res[i] -= v
	}
	return res
}

func divBy(A []int64, d int) ([]int64, bool) {
	if len(A) <= d {
		for _, v := range A {
			if v != 0 {
				return nil, false
			}
		}
		return []int64{0}, true
	}
	quotient := make([]int64, len(A)-d)
	rem := make([]int64, len(A))
	copy(rem, A)
	for i := len(rem) - 1; i >= d; i-- {
		q := rem[i]
		quotient[i-d] = q
		rem[i-d] += q
	}
	for i := 0; i < d; i++ {
		if rem[i] != 0 {
			return nil, false
		}
	}
	return quotient, true
}
```