```go
package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"os"
)

type State struct {
	sum       int32
	prev_mask uint16
	prev_r    int8
}

var dp [1 << 15][15][16]State
var tc_id [1 << 15][15][16]uint16
var sum_of_sub [1 << 15]int32

type ValidState struct {
	r   int8
	m   int8
	sum int32
}

var vs [256]ValidState

type Merge struct {
	from int
	to   int
}

type Op struct {
	i, j int
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, bufio.MaxScanTokenSize)

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

	scanInt := func() int {
		scanner.Scan()
		res := 0
		for _, b := range scanner.Bytes() {
			res = res*10 + int(b-'0')
		}
		return res
	}

	if !scanner.Scan() {
		return
	}

	resT := 0
	for _, b := range scanner.Bytes() {
		resT = resT*10 + int(b-'0')
	}
	T := uint16(resT)

	var a [15]int32

	for current_tc := uint16(1); current_tc <= T; current_tc++ {
		n := scanInt()
		for i := 0; i < n; i++ {
			a[i] = int32(scanInt())
		}

		sum_of_sub[0] = 0
		for sub := 1; sub < 1<<n; sub++ {
			lsb := sub & -sub
			if sub == lsb {
				sum_of_sub[sub] = a[bits.TrailingZeros32(uint32(sub))]
			} else {
				sum_of_sub[sub] = sum_of_sub[sub^lsb] + sum_of_sub[lsb]
			}

			r := int8(bits.TrailingZeros32(uint32(sub)))
			dp[sub][r][1] = State{sum: sum_of_sub[sub], prev_mask: 0, prev_r: -1}
			tc_id[sub][r][1] = current_tc
		}

		for mask := 1; mask < 1<<n; mask++ {
			vs_count := 0
			for r := 0; r < n; r++ {
				for m := 1; m <= n; m++ {
					if tc_id[mask][r][m] == current_tc {
						vs[vs_count] = ValidState{r: int8(r), m: int8(m), sum: dp[mask][r][m].sum}
						vs_count++
					}
				}
			}

			if vs_count == 0 {
				continue
			}

			comp := ((1 << n) - 1) ^ mask
			for sub := comp; sub > 0; sub = (sub - 1) & comp {
				s_sum := sum_of_sub[sub]
				for i := 0; i < vs_count; i++ {
					if s_sum > vs[i].sum {
						masked := uint32(sub) & (0xFFFFFFFF << (vs[i].r + 1))
						if masked != 0 {
							new_r := int8(bits.TrailingZeros32(masked))
							nm := mask | sub
							nm_m := vs[i].m + 1

							if tc_id[nm][new_r][nm_m] != current_tc || dp[nm][new_r][nm_m].sum > s_sum {
								dp[nm][new_r][nm_m] = State{
									sum:       s_sum,
									prev_mask: uint16(mask),
									prev_r:    vs[i].r,
								}
								tc_id[nm][new_r][nm_m] = current_tc
							}
						}
					}
				}
			}
		}

		best_m := int8(-1)
		best_r := int8(-1)
		full_mask := (1 << n) - 1
		for m := n; m >= 1; m-- {
			for r := 0; r < n; r++ {
				if tc_id[full_mask][r][m] == current_tc {
					best_m = int8(m)
					best_r = int8(r)
					break
				}
			}
			if best_m != -1 {
				break
			}
		}

		var merges []Merge
		curr_mask := uint16(full_mask)
		curr_r := best_r
		curr_m := best_m

		for curr_m > 0 {
			state := dp[curr_mask][curr_r][curr_m]
			prev_mask := state.prev_mask
			prev_r := state.prev_r

			sub := curr_mask ^ prev_mask

			for i := 0; i < n; i++ {
				if i != int(curr_r) && (sub&(1<<i)) != 0 {
					merges = append(merges, Merge{from: i, to: int(curr_r)})
				}
			}

			curr_mask = prev_mask
			curr_r = prev_r
			curr_m--
		}

		current_array := make([]int, n)
		for i := 0; i < n; i++ {
			current_array[i] = i
		}

		ops := make([]Op, 0, len(merges))
		for _, merge := range merges {
			from_idx := -1
			to_idx := -1
			for i, orig := range current_array {
				if orig == merge.from {
					from_idx = i
				}
				if orig == merge.to {
					to_idx = i
				}
			}
			ops = append(ops, Op{i: from_idx + 1, j: to_idx + 1})
			current_array = append(current_array[:from_idx], current_array[from_idx+1:]...)
		}

		fmt.Fprintln(out, len(ops))
		for _, op := range ops {
			fmt.Fprintln(out, op.i, op.j)
		}
	}
}
```