```go
package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"os"
	"sort"
	"strconv"
)

type Dancer struct {
	val int64
	id  int
}

type State struct {
	sum        int64
	Z          int
	v          int
	next_v     int
	parent     *State
	change_idx int
	change_val int
}

type PriorityQueue []*State

func (pq PriorityQueue) Len() int           { return len(pq) }
func (pq PriorityQueue) Less(i, j int) bool { return pq[i].sum < pq[j].sum }
func (pq PriorityQueue) Swap(i, j int)      { pq[i], pq[j] = pq[j], pq[i] }
func (pq *PriorityQueue) Push(x interface{}) {
	*pq = append(*pq, x.(*State))
}
func (pq *PriorityQueue) Pop() interface{} {
	old := *pq
	n := len(old)
	x := old[n-1]
	*pq = old[0 : n-1]
	return x
}

type Result struct {
	size int
	sum  int64
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, 10*1024*1024)

	var nextInt = func() int {
		scanner.Scan()
		res, _ := strconv.Atoi(scanner.Text())
		return res
	}
	var nextInt64 = func() int64 {
		scanner.Scan()
		res, _ := strconv.ParseInt(scanner.Text(), 10, 64)
		return res
	}

	scanner.Scan()
	t_str := scanner.Text()
	if t_str == "" {
		return
	}
	t, _ := strconv.Atoi(t_str)

	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	for tc := 0; tc < t; tc++ {
		n := nextInt()
		k := nextInt64()
		m := nextInt()

		dancers := make([]Dancer, n+1)
		for i := 1; i <= n; i++ {
			dancers[i] = Dancer{val: nextInt64(), id: i}
		}

		sort.Slice(dancers[1:], func(i, j int) bool {
			return dancers[i+1].val < dancers[j+1].val
		})

		A := make([]int64, n+1)
		pref := make([]int64, n+1)
		for i := 1; i <= n; i++ {
			A[i] = dancers[i].val
			pref[i] = pref[i-1] + A[i]
		}

		curr_S := 0
		for i := n; i >= 1; i-- {
			if pref[i] <= k {
				curr_S = i
				break
			}
		}

		if curr_S == 0 {
			fmt.Fprintln(out, 0)
			continue
		}

		r := 0
		results := make([]Result, 0, m)
		var last_state *State
		var last_S int

		for curr_S >= 1 && r < m {
			st := &State{
				sum:        pref[curr_S],
				Z:          curr_S,
				v:          n + 1,
				next_v:     n + 1,
				parent:     nil,
				change_idx: 0,
				change_val: 0,
			}

			pq := &PriorityQueue{}
			heap.Init(pq)
			heap.Push(pq, st)

			for pq.Len() > 0 && r < m {
				curr := heap.Pop(pq).(*State)

				if curr.sum > k {
					break
				}

				r++
				results = append(results, Result{size: curr_S, sum: curr.sum})
				last_state = curr
				last_S = curr_S

				if curr.Z >= 1 && curr.Z < n {
					new_sum := curr.sum - A[curr.Z] + A[curr.Z+1]
					child1 := &State{
						sum:        new_sum,
						Z:          curr.Z - 1,
						v:          curr.Z + 1,
						next_v:     curr.v,
						parent:     curr,
						change_idx: curr.Z,
						change_val: curr.Z + 1,
					}
					heap.Push(pq, child1)
				}

				if curr.Z < curr_S && curr.v+1 < curr.next_v {
					new_sum := curr.sum - A[curr.v] + A[curr.v+1]
					child2 := &State{
						sum:        new_sum,
						Z:          curr.Z,
						v:          curr.v + 1,
						next_v:     curr.next_v,
						parent:     curr,
						change_idx: curr.Z + 1,
						change_val: curr.v + 1,
					}
					heap.Push(pq, child2)
				}
			}
			curr_S--
		}

		fmt.Fprintln(out, r)
		for _, res := range results {
			fmt.Fprintf(out, "%d %d\n", res.size, res.sum)
		}

		var path []*State
		curr_node := last_state
		for curr_node != nil {
			path = append(path, curr_node)
			curr_node = curr_node.parent
		}

		subset := make([]int, last_S+1)
		for j := 1; j <= last_S; j++ {
			subset[j] = j
		}

		for i := len(path) - 1; i >= 0; i-- {
			st := path[i]
			if st.change_idx != 0 {
				subset[st.change_idx] = st.change_val
			}
		}

		for j := 1; j <= last_S; j++ {
			fmt.Fprintf(out, "%d", dancers[subset[j]].id)
			if j < last_S {
				fmt.Fprint(out, " ")
			}
		}
		fmt.Fprintln(out)
	}
}
```