package main

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

type FastScanner struct {
	data []byte
	idx  int
}

func (fs *FastScanner) nextInt() int {
	for fs.idx < len(fs.data) && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
	val := 0
	for fs.idx < len(fs.data) && fs.data[fs.idx] > ' ' {
		val = val*10 + int(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return val
}

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

func zFunction(s []byte) []int {
	n := len(s)
	z := make([]int, n)
	l, r := 0, 0
	for i := 1; i < n; i++ {
		if i <= r {
			if z[i-l] < r-i+1 {
				z[i] = z[i-l]
			} else {
				z[i] = r - i + 1
			}
		}
		for i+z[i] < n && s[z[i]] == s[i+z[i]] {
			z[i]++
		}
		if i+z[i]-1 > r {
			l = i
			r = i + z[i] - 1
		}
	}
	return z
}

func pairCount(x, y, b int) int64 {
	if b >= x+y {
		return int64(x+1) * int64(y+1)
	}
	p1 := b - y
	if p1 > x {
		p1 = x
	}
	var res int64
	if p1 >= 0 {
		res += int64(p1+1) * int64(y+1)
	} else {
		p1 = -1
	}
	l := p1 + 1
	if l < 0 {
		l = 0
	}
	r := x
	if b < r {
		r = b
	}
	if l <= r {
		cnt := int64(r - l + 1)
		sumP := int64(l+r) * cnt / 2
		res += cnt*int64(b+1) - sumP
	}
	return res
}

func solve(s []byte) int64 {
	n := len(s)
	core := make([]byte, 0, n)
	c := make([]int, 1, n+1)

	i := 0
	for i < n && s[i] == 'a' {
		i++
	}
	c[0] = i

	for i < n {
		core = append(core, s[i])
		i++
		cnt := 0
		for i < n && s[i] == 'a' {
			cnt++
			i++
		}
		c = append(c, cnt)
	}

	m := len(core)
	if m == 0 {
		return int64(n - 1)
	}

	z := zFunction(core)
	var ans int64

	process := func(d int) {
		if d == m {
			ans += int64(c[0]+1) * int64(c[m]+1)
			return
		}
		if z[d] < m-d {
			return
		}
		b := int(^uint(0) >> 1)
		for i := d; i < m; i += d {
			if c[i] < b {
				b = c[i]
			}
		}
		ok := true
		for r := 1; r < d && ok; r++ {
			v := c[r]
			for i := r + d; i < m; i += d {
				if c[i] != v {
					ok = false
					break
				}
			}
		}
		if ok {
			ans += pairCount(c[0], c[m], b)
		}
	}

	for d := 1; d*d <= m; d++ {
		if m%d == 0 {
			process(d)
			if d*d != m {
				process(m / d)
			}
		}
	}

	return ans
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := FastScanner{data: data}
	t := fs.nextInt()
	out := make([]byte, 0, t*20)
	for ; t > 0; t-- {
		s := fs.nextBytes()
		ans := solve(s)
		out = strconv.AppendInt(out, ans, 10)
		out = append(out, '\n')
	}
	_, _ = os.Stdout.Write(out)
}