9 10
6 2 3 1 4 8 5 9 8
3 9
6 6
9 9
9 9
9 9
2 3
3 9
3 8
6 9
5 6
 10 10
5 10 9 2 9 3 5 5 6 5
5 10
2 2
3 10
4 8
1 3
1 5
5 5
10 10
8 9
6 10
 8 10
100 100 100 100 100 100 100 100
1 8
2 8
3 8
4 8
5 8
6 8
7 8
8 8
1 1
1 5
 5 15
103 45 103 67 45
1 1
1 2
1 3
1 4
1 5
2 2
2 3
2 4
2 5
3 3
3 4
3 5
4 4
4 5
5 5
 1 1
1000000
1 1
 10 5
10 9 8 7 6 5 4 3 2 1
4 8
1 10
3 9
2 2
5 10
 9 10
5 3 10 2 4 8 7 5 1
6 9
1 8
3 3
2 7
3 5
4 6
9 9
8 8
1 9
5 6
 9 10
10 2 6 2 4 6 6 4 1
4 8
8 9
2 3
8 9
9 9
4 5
1 7
6 6
6 8
1 1
 20 8
1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2
4 15
1 2
2 20
7 7
13 18
7 7
3 19
3 8
 1 2
1
1 1
1 1
 8 10
5 7 3 1 4 2 1 1
5 7
3 8
2 7
4 8
4 5
2 8
4 6
1 2
4 7
3 5

54
8
8
8
8
5
54
30
46
12
 63
10
92
34
24
53
9
5
11
54
 6400
4900
3600
2500
1600
900
400
100
100
2500
 103
148
457
524
659
45
148
215
350
103
170
215
67
112
45
 1000000
 25
55
35
9
21
 21
54
10
34
16
14
1
5
55
12
 42
5
8
5
1
6
76
6
28
10
 108
3
281
1
27
1
209
27
 1
1
 7
18
20
15
5
25
7
12
10
8

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;

public class Main {
	public static int SQRT;
	
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb = new StringBuilder();
		
		String line = br.readLine();
		String[] split = line.split(" ");
		int N = Integer.parseInt(split[0]);
		SQRT = (int) Math.sqrt(N);
		int Q = Integer.parseInt(split[1]);
		
		line = br.readLine();
		split = line.split(" ");
		int[] arr = new int[N];
		for(int i = 0; i<N; i++) arr[i] = Integer.parseInt(split[i]);
		
		Query[] sortedQueries = new Query[Q];
		Query[] unsortedQueries = new Query[Q];
		for(int i = 0; i<Q; i++){
			line = br.readLine();
			split = line.split(" ");
			int L = Integer.parseInt(split[0]);
			int R = Integer.parseInt(split[1]);
			Query qq = new Query(L-1, R-1);
			sortedQueries[i] = qq;
			unsortedQueries[i] = qq;
		}
		Arrays.sort(sortedQueries);
		
		
		int[] occur = new int[1000001];
		Arrays.fill(occur, 0);
		long total = arr[0];
		occur[arr[0]] = 1;
		int currentL = 0;
		int currentR = 0;
		for(Query q : sortedQueries){
			//MOVE R
		while(q.R < currentR){
			//move currentR left	
			total += arr[currentR]*(1-occur[arr[currentR]]-occur[arr[currentR]]);
			occur[arr[currentR]]--;
			currentR--;
		}
		while(q.R > currentR){
			//move currentR right
			currentR++;
			total += arr[currentR]*(1+occur[arr[currentR]]+occur[arr[currentR]]);
			occur[arr[currentR]]++;
		}
		
		//MOVE L
		while(q.L < currentL){
			//move currentL left
			currentL--;
			total += arr[currentL]*(1+occur[arr[currentL]]+occur[arr[currentL]]);
			occur[arr[currentL]]++;
		}
		while(q.L > currentL){
			//move currentL right
			total += arr[currentL]*(1-occur[arr[currentL]]-occur[arr[currentL]]);
			occur[arr[currentL]]--;
			currentL++;
		}
			q.ans = total;
		}
		for(Query q : unsortedQueries){
			sb.append(q.ans);
			sb.append("\n");
		}
		System.out.print(sb);
	}
}

class Query implements Comparable<Query>{
	int L;
	int R;
	int bucket;
	long ans;
	Query(int l, int r){
		L = l;
		R = r;
		bucket = L / Main.SQRT;
	}
	
	@Override
	public int compareTo(Query q) {
		int dif = bucket - q.bucket;
		if(dif == 0) return R - q.R;
		return dif;
	}
}