```go
package main

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

const MOD = int64(1e9 + 7)

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

	var n int
	fmt.Fscan(reader, &n)
	var s string
	fmt.Fscan(reader, &s)

	val := make([][]int, n)
	for i := 0; i < n; i++ {
		val[i] = make([]int, n+1)
		for j := range val[i] {
			val[i][j] = -1
		}
		v := 0
		started := false
		for j := i; j < n; j++ {
			if s[j] == '1' {
				started = true
			}
			if started {
				v = v*2 + int(s[j]-'0')
				if v > n {
					break
				}
				val[i][j+1] = v
			}
		}
	}

	type Mask [10]byte
	dp := make([][]map[Mask]int64, n+1)
	for i := range dp {
		dp[i] = make([]map[Mask]int64, n+2)
		for j := range dp[i] {
			dp[i][j] = make(map[Mask]int64)
		}
	}

	for i := 0; i < n; i++ {
		for j := i + 1; j <= n; j++ {
			v := val[i][j]
			if v == 1 {
				var m Mask
				m[0] = 1
				dp[j][1][m] = (dp[j][1][m] + 1) % MOD
			}
		}
	}

	for i := 0; i <= n; i++ {
		for c := 1; c <= n; c++ {
			for mask, ways := range dp[i][c] {
				if ways == 0 {
					continue
				}
				for j := i + 1; j <= n; j++ {
					v := val[i][j]
					if v <= 0 || v > n {
						continue
					}
					newMask := mask
					idx := (v - 1) / 8
					bit := byte(1) << ((v - 1) % 8)
					newMask[idx] |= bit
					newC := c + 1
					if newC <= n {
						dp[j][newC][newMask] = (dp[j][newC][newMask] + ways) % MOD
					}
				}
			}
		}
	}

	var ans int64 = 0
	for i := 1; i <= n; i++ {
		for c := 1; c <= n; c++ {
			for mask, ways := range dp[i][c] {
				m := 0
				for v := n; v >= 1; v-- {
					idx := (v - 1) / 8
					bit := byte(1) << ((v - 1) % 8)
					if mask[idx]&bit != 0 {
						m = v
						break
					}
				}
				if m == 0 {
					continue
				}
				valid := true
				for v := 1; v <= m; v++ {
					idx := (v - 1) / 8
					bit := byte(1) << ((v - 1) % 8)
					if mask[idx]&bit == 0 {
						valid = false
						break
					}
				}
				if valid {
					ans = (ans + ways) % MOD
				}
			}
		}
	}

	fmt.Fprintln(writer, ans)
}
```