package main

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

const INF int32 = 1 << 30

type Matrix [25]int32

var baseInf Matrix
var id Matrix
var mats [10]Matrix

func makeMatrix(c byte) Matrix {
	m := baseInf
	for i := 0; i < 5; i++ {
		m[i*5+i] = 1
	}
	for i := 0; i < 5; i++ {
		ok := true
		j := i
		switch i {
		case 0:
			if c == '2' {
				j = 1
			}
		case 1:
			if c == '0' {
				j = 2
			}
		case 2:
			if c == '1' {
				j = 3
			}
		case 3:
			if c == '6' {
				ok = false
			} else if c == '7' {
				j = 4
			}
		case 4:
			if c == '6' {
				ok = false
			}
		}
		if ok {
			m[i*5+j] = 0
		}
	}
	return m
}

func mul(a, b *Matrix) Matrix {
	c := baseInf
	for i := 0; i < 5; i++ {
		ri := i * 5
		for k := i; k < 5; k++ {
			best := INF
			for j := i; j <= k; j++ {
				av := (*a)[ri+j]
				bv := (*b)[j*5+k]
				if av == INF || bv == INF {
					continue
				}
				v := av + bv
				if v < best {
					best = v
				}
			}
			c[ri+k] = best
		}
	}
	return c
}

func init() {
	for i := 0; i < 25; i++ {
		baseInf[i] = INF
	}
	id = baseInf
	for i := 0; i < 5; i++ {
		id[i*5+i] = 0
	}
	for d := 0; d < 10; d++ {
		mats[d] = makeMatrix(byte('0' + d))
	}
}

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func (fs *FastScanner) skip() {
	for fs.idx < fs.n && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
}

func (fs *FastScanner) nextInt() int {
	fs.skip()
	val := 0
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if c <= ' ' {
			break
		}
		val = val*10 + int(c-'0')
		fs.idx++
	}
	return val
}

func (fs *FastScanner) nextToken() []byte {
	fs.skip()
	start := fs.idx
	for fs.idx < fs.n && fs.data[fs.idx] > ' ' {
		fs.idx++
	}
	return fs.data[start:fs.idx]
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := FastScanner{data: data, n: len(data)}

	n := fs.nextInt()
	q := fs.nextInt()
	s := fs.nextToken()

	size := 1
	for size < n {
		size <<= 1
	}

	tree := make([]Matrix, size<<1)
	for i := size; i < size<<1; i++ {
		tree[i] = id
	}
	for i := 0; i < n; i++ {
		tree[size+i] = mats[s[i]-'0']
	}
	for i := size - 1; i > 0; i-- {
		tree[i] = mul(&tree[i<<1], &tree[i<<1|1])
	}

	out := make([]byte, 0, q*8)
	for ; q > 0; q-- {
		l := fs.nextInt() - 1 + size
		r := fs.nextInt() + size

		left := id
		right := id

		for l < r {
			if l&1 == 1 {
				left = mul(&left, &tree[l])
				l++
			}
			if r&1 == 1 {
				r--
				right = mul(&tree[r], &right)
			}
			l >>= 1
			r >>= 1
		}

		res := mul(&left, &right)
		ans := res[4]
		if ans == INF {
			out = strconv.AppendInt(out, -1, 10)
		} else {
			out = strconv.AppendInt(out, int64(ans), 10)
		}
		out = append(out, '\n')
	}

	os.Stdout.Write(out)
}