package main

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

type Substring struct {
	idx int
	len int
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n, m int
	var k int64
	fmt.Fscan(reader, &n, &m, &k)

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

	lcp := make([][]int, n+1)
	for i := range lcp {
		lcp[i] = make([]int, n+1)
	}
	for i := n - 1; i >= 0; i-- {
		for j := n - 1; j >= 0; j-- {
			if s[i] == s[j] {
				lcp[i][j] = 1 + lcp[i+1][j+1]
			} else {
				lcp[i][j] = 0
			}
		}
	}

	sa := make([]int, n)
	for i := 0; i < n; i++ {
		sa[i] = i
	}
	sort.Slice(sa, func(i, j int) bool {
		a, b := sa[i], sa[j]
		l := lcp[a][b]
		if a+l == n {
			return true
		}
		if b+l == n {
			return false
		}
		return s[a+l] < s[b+l]
	})

	var subs []Substring
	for i := 0; i < n; i++ {
		startLen := 1
		if i > 0 {
			startLen = lcp[sa[i-1]][sa[i]] + 1
		}
		for l := startLen; l <= n-sa[i]; l++ {
			subs = append(subs, Substring{sa[i], l})
		}
	}

	low := 0
	high := len(subs) - 1
	best := -1

	for low <= high {
		mid := (low + high) / 2
		idx := subs[mid].idx
		length := subs[mid].len

		L := make([]int, n)
		for p := 0; p < n; p++ {
			l := lcp[p][idx]
			if l >= length {
				L[p] = length
			} else {
				if p+l < n && s[p+l] > s[idx+l] {
					L[p] = l + 1
				} else {
					L[p] = -1
				}
			}
		}

		dp := make([]int64, n+1)
		dp[0] = 1

		for j := 1; j <= m; j++ {
			add := make([]int64, n+2)
			for p := 0; p < n; p++ {
				if dp[p] > 0 && L[p] != -1 && p+L[p] <= n {
					add[p+L[p]] += dp[p]
					if add[p+L[p]] > k {
						add[p+L[p]] = k
					}
				}
			}
			nextDp := make([]int64, n+1)
			var curr int64 = 0
			for i := 1; i <= n; i++ {
				curr += add[i]
				if curr > k {
					curr = k
				}
				nextDp[i] = curr
			}
			dp = nextDp
		}

		if dp[n] >= k {
			best = mid
			low = mid + 1
		} else {
			high = mid - 1
		}
	}

	if best != -1 {
		fmt.Println(s[subs[best].idx : subs[best].idx+subs[best].len])
	}
}