package main

import (
	"bufio"
	"bytes"
	"io"
	"os"
	"strconv"
)

type FastScanner struct {
	data []byte
	idx  int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data}
}

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

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

func find(parent []int, x int) int {
	root := x
	for parent[root] != root {
		root = parent[root]
	}
	for parent[x] != x {
		p := parent[x]
		parent[x] = root
		x = p
	}
	return root
}

func zFunction(s string) []int {
	n := len(s)
	z := make([]int, n)
	if n == 0 {
		return z
	}
	z[0] = n
	l, r := 0, 0
	for i := 1; i < n; i++ {
		if i <= r {
			v := z[i-l]
			if v > r-i+1 {
				v = r - i + 1
			}
			z[i] = v
		}
		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 main() {
	fs := NewFastScanner()
	t := fs.nextInt()
	var out bytes.Buffer

	for ; t > 0; t-- {
		n := fs.nextInt()
		l := fs.nextInt()
		r := fs.nextInt()
		s := fs.nextString()

		z := zFunction(s)
		buckets := make([][]int, n+1)
		parent := make([]int, n+2)
		for i := 1; i <= n+1; i++ {
			parent[i] = i
		}

		for i := 1; i < n; i++ {
			pos := i + 1
			if z[i] == 0 {
				parent[pos] = find(parent, pos+1)
			} else {
				buckets[z[i]] = append(buckets[z[i]], pos)
			}
		}

		best := make([]int, n+2)

		for x := 1; x <= n; x++ {
			limit := n - x + 1
			cnt := 0
			pos := 1
			for pos <= limit {
				cnt++
				pos = find(parent, pos+x)
			}
			if x > best[cnt] {
				best[cnt] = x
			}
			for _, p := range buckets[x] {
				parent[p] = find(parent, p+1)
			}
		}

		for k := n - 1; k >= 1; k-- {
			if best[k+1] > best[k] {
				best[k] = best[k+1]
			}
		}

		for k := l; k <= r; k++ {
			if k > l {
				out.WriteByte(' ')
			}
			out.WriteString(strconv.Itoa(best[k]))
		}
		out.WriteByte('\n')
	}

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	w.Write(out.Bytes())
	w.Flush()
}