package main

import (
	"fmt"
	"io"
	"os"
)

var (
	n, k, x   int
	maxA      int
	highestBit int
	a         []int
	countTree []int
	sumTree   []int64
	nextPos   []int
	freq      []int
)

func addVal(v, delta int) {
	dv := int64(delta) * int64(v)
	for i := v; i <= maxA; i += i & -i {
		countTree[i] += delta
		sumTree[i] += dv
	}
}

func sumSmallestK(k int) int64 {
	idx, cnt := 0, 0
	var sum int64
	for bit := highestBit; bit > 0; bit >>= 1 {
		next := idx + bit
		if next <= maxA && cnt+countTree[next] < k {
			idx = next
			cnt += countTree[next]
			sum += sumTree[next]
		}
	}
	return sum + int64(k-cnt)*int64(idx+1)
}

func check(limit int64) bool {
	for i := range countTree {
		countTree[i] = 0
	}
	for i := range sumTree {
		sumTree[i] = 0
	}

	r, totalCnt := 0, 0
	for l := 0; l < n; l++ {
		ok := false
		for {
			if totalCnt >= x && sumSmallestK(x) <= limit {
				ok = true
				break
			}
			if r == n {
				break
			}
			addVal(a[r], 1)
			totalCnt++
			r++
		}
		if ok {
			nextPos[l] = r
		} else {
			nextPos[l] = n + 1
		}
		addVal(a[l], -1)
		totalCnt--
	}

	need := n - k
	kept := 0
	start := 0
	for start < n {
		np := nextPos[start]
		if np > n {
			break
		}
		start = np
		kept += x
		if kept >= need {
			return true
		}
	}

	for i := range freq {
		freq[i] = 0
	}
	for i := start; i < n; i++ {
		freq[a[i]]++
	}

	rem := limit
	for v := 1; v <= maxA; v++ {
		c := freq[v]
		if c == 0 {
			continue
		}
		take := rem / int64(v)
		if take > int64(c) {
			take = int64(c)
		}
		kept += int(take)
		if kept >= need {
			return true
		}
		rem -= take * int64(v)
	}

	return false
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	pos := 0
	nextInt := func() int {
		for pos < len(data) && (data[pos] < '0' || data[pos] > '9') {
			pos++
		}
		val := 0
		for pos < len(data) && data[pos] >= '0' && data[pos] <= '9' {
			val = val*10 + int(data[pos]-'0')
			pos++
		}
		return val
	}

	n = nextInt()
	k = nextInt()
	x = nextInt()

	a = make([]int, n)
	var total int64
	for i := 0; i < n; i++ {
		a[i] = nextInt()
		total += int64(a[i])
		if a[i] > maxA {
			maxA = a[i]
		}
	}

	if k == n {
		fmt.Print(0)
		return
	}

	countTree = make([]int, maxA+2)
	sumTree = make([]int64, maxA+2)
	nextPos = make([]int, n+1)
	freq = make([]int, maxA+1)

	highestBit = 1
	for highestBit <= maxA {
		highestBit <<= 1
	}
	highestBit >>= 1

	low, high := int64(-1), total
	for high-low > 1 {
		mid := (low + high) / 2
		if check(mid) {
			high = mid
		} else {
			low = mid
		}
	}

	fmt.Print(high)
}