```go
package main

import (
    "fmt"
    "sort"
)

func solve() {
    var n int
    fmt.Scan(&n)
    
    a := make([]int, n)
    for i := 0; i < n; i++ {
        fmt.Scan(&a[i])
    }
    
    count := make(map[int]int)
    for _, x := range a {
        count[x]++
    }
    
    pairs := []int{}
    leftovers := []int{}
    for length, cnt := range count {
        for i := 0; i < cnt/2; i++ {
            pairs = append(pairs, length)
        }
        if cnt%2 == 1 {
            leftovers = append(leftovers, length)
        }
    }
    
    sort.Sort(sort.Reverse(sort.IntSlice(pairs)))
    sort.Sort(sort.Reverse(sort.IntSlice(leftovers)))
    
    var totalPairsSum int64
    for _, p := range pairs {
        totalPairsSum += int64(p)
    }
    
    best := int64(0)
    
    if len(pairs) >= 1 {
        for _, mid := range leftovers {
            perimeter := 2*totalPairsSum + int64(mid)
            maxSide := int64(pairs[0])
            if int64(mid) > maxSide {
                maxSide = int64(mid)
            }
            if perimeter > 2*maxSide {
                if perimeter > best {
                    best = perimeter
                }
            }
        }
        
        mid := pairs[len(pairs)-1]
        remainingPairsSum := totalPairsSum - int64(mid)
        perimeter := 2*remainingPairsSum + int64(mid)
        maxSide := int64(mid)
        if len(pairs) > 1 && int64(pairs[0]) > maxSide {
            maxSide = int64(pairs[0])
        }
        if perimeter > 2*maxSide {
            if perimeter > best {
                best = perimeter
            }
        }
    }
    
    if len(pairs) >= 2 {
        perimeter := 2 * totalPairsSum
        if perimeter > best {
            best = perimeter
        }
    }
    
    if len(pairs) >= 1 {
        if len(leftovers) >= 2 {
            mid1, mid2 := leftovers[0], leftovers[1]
            perimeter := 2*totalPairsSum + int64(mid1) + int64(mid2)
            maxSide := int64(pairs[0])
            if int64(mid1) > maxSide {
                maxSide = int64(mid1)
            }
            if int64(mid2) > maxSide {
                maxSide = int64(mid2)
            }
            if perimeter > 2*maxSide {
                if perimeter > best {
                    best = perimeter
                }
            }
        }
        
        if len(leftovers) >= 1 && len(pairs) >= 2 {
            mid1 := leftovers[0]
            mid2 := pairs[len(pairs)-1]
            remainingPairsSum := totalPairsSum - int64(mid2)
            perimeter := 2*remainingPairsSum + int64(mid1) + int64(mid2)
            maxSide := int64(pairs[0])
            if int64(mid1) > maxSide {
                maxSide = int64(mid1)
            }
            if int64(mid2) > maxSide {
                maxSide = int64(mid2)
            }
            if perimeter > 2*maxSide {
                if perimeter > best {
                    best = perimeter
                }
            }
        }
        
        if len(pairs) >= 3 {
            mid1 := pairs[len(pairs)-2]
            mid2 := pairs[len(pairs)-1]
            remainingPairsSum := totalPairsSum - int64(mid1) - int64(mid2)
            perimeter := 2*remainingPairsSum + int64(mid1) + int64(mid2)
            maxSide := int64(pairs[0])
            if int64(mid1) > maxSide {
                maxSide = int64(mid1)
            }
            if int64(mid2) > maxSide {
                maxSide = int64(mid2)
            }
            if perimeter > 2*maxSide {
                if perimeter > best {
                    best = perimeter
                }
            }
        }
    }
    
    fmt.Println(best)
}

func main() {
    var t int
    fmt.Scan(&t)
    for i := 0; i < t; i++ {
        solve()
    }
}
```