```go
package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var t int
	fmt.Fscan(in, &t)
	for tc := 0; tc < t; tc++ {
		var n, m int
		fmt.Fscan(in, &n, &m)
		a := make([]int, n)
		for i := 0; i < n; i++ {
			fmt.Fscan(in, &a[i])
		}

		freq := make(map[int]int)
		for _, v := range a {
			freq[v]++
		}

		byFreq := make(map[int][]int)
		for v, c := range freq {
			byFreq[c] = append(byFreq[c], v)
		}

		bad := make(map[int]map[int]struct{})
		for i := 0; i < m; i++ {
			var x, y int
			fmt.Fscan(in, &x, &y)
			if _, ok := bad[x]; !ok {
				bad[x] = make(map[int]struct{})
			}
			bad[x][y] = struct{}{}
			if _, ok := bad[y]; !ok {
				bad[y] = make(map[int]struct{})
			}
			bad[y][x] = struct{}{}
		}

		for c := range byFreq {
			sort.Slice(byFreq[c], func(i, j int) bool {
				return byFreq[c][i] > byFreq[c][j]
			})
		}

		counts := make([]int, 0, len(byFreq))
		for c := range byFreq {
			counts = append(counts, c)
		}

		var ans int64 = 0

		for _, c := range counts {
			L := byFreq[c]
			if len(L) < 2 {
				continue
			}
			sumc := int64(c + c)
			for i, x := range L {
				bestPartner := L[0]
				if i == 0 {
					bestPartner = L[1]
				}
				if sumc*(int64(x)+int64(bestPartner)) <= ans {
					break
				}
				for j, y := range L {
					if i == j {
						continue
					}
					if inner, ok := bad[x]; ok {
						if _, isBad := inner[y]; isBad {
							continue
						}
					}
					val := sumc * int64(x+y)
					if val > ans {
						ans = val
					}
					break
				}
			}
		}

		for i := 0; i < len(counts); i++ {
			c1 := counts[i]
			L1 := byFreq[c1]
			for j := i + 1; j < len(counts); j++ {
				c2 := counts[j]
				L2 := byFreq[c2]

				if len(L1) > len(L2) {
					c1, c2 = c2, c1
					L1, L2 = L2, L1
				}

				sumc := int64(c1 + c2)
				for _, x := range L1 {
					if sumc*(int64(x)+int64(L2[0])) <= ans {
						break
					}
					for _, y := range L2 {
						if inner, ok := bad[x]; ok {
							if _, isBad := inner[y]; isBad {
								continue
							}
						}
						val := sumc * int64(x+y)
						if val > ans {
							ans = val
						}
						break
					}
				}
			}
		}

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