```go
package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	var R, G, B int
	fmt.Fscan(in, &R, &G, &B)

	r := make([]int, R)
	for i := 0; i < R; i++ {
		fmt.Fscan(in, &r[i])
	}
	g := make([]int, G)
	for i := 0; i < G; i++ {
		fmt.Fscan(in, &g[i])
	}
	b := make([]int, B)
	for i := 0; i < B; i++ {
		fmt.Fscan(in, &b[i])
	}

	sort.Sort(sort.Reverse(sort.IntSlice(r)))
	sort.Sort(sort.Reverse(sort.IntSlice(g)))
	sort.Sort(sort.Reverse(sort.IntSlice(b)))

	// dp[i][j][k] stores the max area using i red, j green, and k blue sticks.
	// We use a flattened 1D array to improve memory locality and reduce overhead.
	dimJ := G + 1
	dimK := B + 1
	dpSize := (R + 1) * dimJ * dimK
	dp := make([]int, dpSize)
	for i := range dp {
		dp[i] = -1
	}

	dp[0] = 0
	ans := 0

	for i := 0; i <= R; i++ {
		for j := 0; j <= G; j++ {
			for k := 0; k <= B; k++ {
				idx := (i*dimJ+j)*dimK + k
				curr := dp[idx]
				if curr == -1 {
					continue
				}
				if curr > ans {
					ans = curr
				}

				// Try pairing Red and Green
				if i < R && j < G {
					nextIdx := ((i+1)*dimJ+(j+1))*dimK + k
					val := curr + r[i]*g[j]
					if val > dp[nextIdx] {
						dp[nextIdx] = val
					}
				}

				// Try pairing Red and Blue
				if i < R && k < B {
					nextIdx := ((i+1)*dimJ+j)*dimK + (k + 1)
					val := curr + r[i]*b[k]
					if val > dp[nextIdx] {
						dp[nextIdx] = val
					}
				}

				// Try pairing Green and Blue
				if j < G && k < B {
					nextIdx := (i*dimJ+(j+1))*dimK + (k + 1)
					val := curr + g[j]*b[k]
					if val > dp[nextIdx] {
						dp[nextIdx] = val
					}
				}
			}
		}
	}

	fmt.Println(ans)
}
```