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

// https://codeforces.com/problemset/problem/86/D

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

public class PowerfulArray {
    static int block_size;
    static int[] frequency;
    static long result;

    private static class Query implements Comparable<Query>{
        int L, R,index;
        Query(int L,int R,int index){
            this.L = L;
            this.R = R;
            this.index = index;
        }

        @Override
        public int compareTo(Query o) {
            if (L /block_size!=o.L /block_size)
                return L /block_size - o.L /block_size;
            return R - o.R;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer sb = new StringBuffer();
        String[] line = br.readLine().split(" ");
        int n = Integer.parseInt(line[0]);
        int q = Integer.parseInt(line[1]);

        int[] input = new int[n];
        line = br.readLine().split(" ");
        for (int i=0;i<n;i++)
            input[i] = Integer.parseInt(line[i]);

        block_size = (int) Math.sqrt(n) + 1;

        Query[] queries = new Query[q];
        for (int i = 0; i<q; i++){
            line = br.readLine().split(" ");
            int L = Integer.parseInt(line[0]) - 1;
            int R = Integer.parseInt(line[1]) - 1;
            queries[i] = new Query(L,R,i);
        }

        Arrays.sort(queries);

        long[] output = new long[q]; // har query k liye answer
        frequency = new int[1000001]; // (constraints)
        result = 0; // make sure result is 0 for multiple test cases

        int L = 0, R = -1;
        for (Query query : queries){
            int index = query.index;

            while (R>query.R){
                remove(input[R]);
                R--;
            }
            while (R<query.R){
                R++;
                update(input[R]);
            }

            while (L<query.L){
                remove(input[L]);
                L++;
            }

            while (L>query.L){
                L--;
                update(input[L]);
            }

            output[index] = result;
        }

        for (long i : output)
            sb.append(i+"\n");

        System.out.print(sb);

    }

    private static void update(int value){
        long prevFreq = frequency[value];
        long currFreq = ++frequency[value];
        long element = value;

        result -= (prevFreq*prevFreq*value);
        result += (currFreq*currFreq*value);
    }

    private static void remove(int value){
        long prevFreq = frequency[value];
        long currFreq = --frequency[value];
        long element = value;

        result -= (prevFreq*prevFreq*value);
        result += (currFreq*currFreq*value);

    }
}
