```go
package main

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

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

	var n, t int
	fmt.Fscan(in, &n, &t)

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

	type Query struct {
		l, r, idx int
	}

	queries := make([]Query, t)
	for i := 0; i < t; i++ {
		var l, r int
		fmt.Fscan(in, &l, &r)
		queries[i] = Query{l - 1, r - 1, i}
	}

	blockSize := int(math.Sqrt(float64(n)))
	if blockSize == 0 {
		blockSize = 1
	}

	sort.Slice(queries, func(i, j int) bool {
		blockI := queries[i].l / blockSize
		blockJ := queries[j].l / blockSize
		if blockI != blockJ {
			return blockI < blockJ
		}
		if blockI%2 == 0 {
			return queries[i].r < queries[j].r
		}
		return queries[i].r > queries[j].r
	})

	freq := make([]int, 1000001)
	ans := make([]int64, t)
	var curAns int64 = 0
	curL, curR := 0, -1

	add := func(pos int) {
		x := a[pos]
		c := freq[x]
		curAns += int64(2*c+1) * int64(x)
		freq[x]++
	}

	remove := func(pos int) {
		x := a[pos]
		c := freq[x]
		curAns -= int64(2*c-1) * int64(x)
		freq[x]--
	}

	for _, q := range queries {
		for curL > q.l {
			curL--
			add(curL)
		}
		for curR < q.r {
			curR++
			add(curR)
		}
		for curL < q.l {
			remove(curL)
			curL++
		}
		for curR > q.r {
			remove(curR)
			curR--
		}
		ans[q.idx] = curAns
	}

	for i := 0; i < t; i++ {
		fmt.Fprintln(out, ans[i])
	}
}
```