```go
package main

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

func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	var t int
	fmt.Fscan(in, &t)

	for ; t > 0; t-- {
		var n, m int
		var v int64
		fmt.Fscan(in, &n, &m, &v)

		a := make([]int64, n+1)
		pref := make([]int64, n+1)
		var total int64
		for i := 1; i <= n; i++ {
			fmt.Fscan(in, &a[i])
			total += a[i]
			pref[i] = pref[i-1] + a[i]
		}

		left := make([]int, n+1)
		var sum int64
		lcnt := 0
		l := 1
		for r := 1; r <= n; r++ {
			sum += a[r]
			for l <= r && sum >= v {
				lcnt++
				sum -= a[l]
				l++
			}
			left[r] = lcnt
		}

		right := make([]int, n+2)
		sum = 0
		rcnt := 0
		r := n
		for l2 := n; l2 >= 1; l2-- {
			sum += a[l2]
			for r >= l2 && sum >= v {
				rcnt++
				sum -= a[r]
				r--
			}
			right[l2] = rcnt
		}
		right[n+1] = 0

		if left[n] < m {
			fmt.Fprintln(out, -1)
			continue
		}

		need := m
		earliest := make([]int, need+1)
		for i := range earliest {
			earliest[i] = n + 1
		}
		earliest[0] = 0
		for i := 1; i <= n; i++ {
			c := left[i]
			if c > need {
				c = need
			}
			if i < earliest[c] {
				earliest[c] = i
			}
		}
		for k := need - 1; k >= 0; k-- {
			if earliest[k] > earliest[k+1] {
				earliest[k] = earliest[k+1]
			}
		}

		latest := make([]int, need+1)
		for i := range latest {
			latest[i] = 0
		}
		for i := 1; i <= n; i++ {
			c := right[i]
			if c > need {
				c = need
			}
			if i > latest[c] {
				latest[c] = i
			}
		}
		for k := need - 1; k >= 0; k-- {
			if latest[k] < latest[k+1] {
				latest[k] = latest[k+1]
			}
		}

		var ans int64 = 0
		for x := 0; x <= m; x++ {
			i := earliest[x]
			j := latest[m-x]
			if i == n+1 || j == 0 {
				continue
			}
			if i < j {
				seg := pref[j-1] - pref[i]
				ans = max(ans, seg)
			} else {
				ans = max(ans, 0)
			}
		}

		fmt.Fprintln(out, ans)
	}
}
```