package main

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

type State struct {
	len  int32
	link int32
	next [26]int32
}

var st []State
var cnt []int32
var vis []int32

var buffer []byte = make([]byte, 1024*1024*4)
var bufLen int
var bufPtr int

func readChar() byte {
	if bufPtr >= bufLen {
		n, _ := os.Stdin.Read(buffer)
		if n == 0 {
			return 0
		}
		bufLen = n
		bufPtr = 0
	}
	c := buffer[bufPtr]
	bufPtr++
	return c
}

func readString() []byte {
	c := readChar()
	for c != 0 && c <= ' ' {
		c = readChar()
	}
	if c == 0 {
		return nil
	}
	res := make([]byte, 0, 64)
	for c > ' ' {
		res = append(res, c)
		c = readChar()
	}
	return res
}

func readInt() int {
	c := readChar()
	for c != 0 && c <= ' ' {
		c = readChar()
	}
	if c == 0 {
		return 0
	}
	res := 0
	for c > ' ' {
		res = res*10 + int(c-'0')
		c = readChar()
	}
	return res
}

func main() {
	s := readString()
	if len(s) == 0 {
		return
	}
	n := len(s)

	st = make([]State, 2*n+2)
	cnt = make([]int32, 2*n+2)
	vis = make([]int32, 2*n+2)

	st[0].len = 0
	st[0].link = -1
	sz := int32(1)
	last := int32(0)

	for i := 0; i < n; i++ {
		c := int32(s[i] - 'a')
		cur := sz
		sz++
		st[cur].len = st[last].len + 1
		cnt[cur] = 1

		p := last
		for p != -1 && st[p].next[c] == 0 {
			st[p].next[c] = cur
			p = st[p].link
		}

		if p == -1 {
			st[cur].link = 0
		} else {
			q := st[p].next[c]
			if st[p].len+1 == st[q].len {
				st[cur].link = q
			} else {
				clone := sz
				sz++
				st[clone].len = st[p].len + 1
				st[clone].next = st[q].next
				st[clone].link = st[q].link
				for p != -1 && st[p].next[c] == q {
					st[p].next[c] = clone
					p = st[p].link
				}
				st[q].link = clone
				st[cur].link = clone
			}
		}
		last = cur
	}

	maxLen := int32(n)
	cArr := make([]int32, maxLen+1)
	for i := int32(1); i < sz; i++ {
		cArr[st[i].len]++
	}
	for i := int32(1); i <= maxLen; i++ {
		cArr[i] += cArr[i-1]
	}
	order := make([]int32, sz)
	for i := int32(1); i < sz; i++ {
		order[cArr[st[i].len]] = i
		cArr[st[i].len]--
	}
	for i := sz - 1; i >= 1; i-- {
		p := order[i]
		link := st[p].link
		if link != -1 {
			cnt[link] += cnt[p]
		}
	}

	qNum := readInt()
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	for q := int32(1); q <= int32(qNum); q++ {
		x := readString()
		L := int32(len(x))
		if L == 0 {
			fmt.Fprintln(out, 0)
			continue
		}
		u := int32(0)
		l := int32(0)
		ans := int32(0)

		for i := int32(0); i < 2*L-1; i++ {
			c := int32(x[i%L] - 'a')
			for u != 0 && st[u].next[c] == 0 {
				u = st[u].link
				l = st[u].len
			}
			if st[u].next[c] != 0 {
				u = st[u].next[c]
				l++
			} else {
				u = 0
				l = 0
			}

			for u != 0 && st[st[u].link].len >= L {
				u = st[u].link
				l = st[u].len
			}

			if l >= L {
				if vis[u] != q {
					vis[u] = q
					ans += cnt[u]
				}
				l = L
			}
		}
		fmt.Fprintln(out, ans)
	}
}