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.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.InputMismatchException;

public class Q2{
	static class InputReader {

		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private String[] s;
		public InputReader(InputStream st) {
			this.stream = st;
		}
		public int read() {
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars) {
				curChar = 0;
				try {
					snumChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (snumChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public int nextInt() {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int[] nextIntArray(int n) {
			int a[] = new int[n];
			s=nextLine().split(" ");
			for (int i = 0; i < n; i++) {
				a[i] = Integer.parseInt(s[i]);
			}
			return a;
		}

		public String readString() {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public String nextLine() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		public boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}

	}
	
	static class Pair{
	    int L;
	    int R;
	    int i;
	    Pair(int L, int R,int i){
	        this.L = L;
	        this.R = R;
	        this.i=i;
	    }
	}
	static long add(long[] freq,int[] num,long Power,int pos) {
		int ele=num[pos];
		long preF=freq[ele];
		long currF=++freq[ele];
		return Power+currF*currF*ele-preF*preF*ele;
	}
	static long remove(long[] freq,int[] num,long Power,int pos) {
		int ele=num[pos];
		long preF=freq[ele];
		long currF=--freq[ele];
		return Power+currF*currF*ele-preF*preF*ele;	
	}
	static long[] queryResults(int n,int[] num, ArrayList<Pair> q, int m){
		long[] freq=new long[1000001];
		long Power=0;
		
		long[] ans=new long[m];
        int block = (int) Math.sqrt(n);
     
        Collections.sort(q, new Comparator<Pair>(){
            public int compare(Pair x, Pair y){
                if (x.L/block != y.L/block)
                    return Integer.compare(x.L, y.L);
                return Integer.compare(x.R, y.R);
            }
        });
        
        int currL = 0, currR = 0;
        for (int i=0; i<m; i++){
            int L = q.get(i).L, R = q.get(i).R;
            while (currL < L){
	            Power=remove(freq,num,Power,currL);
	            currL++;
            }
            while (currL > L){
            	Power=add(freq,num,Power,--currL);
            }
            while (currR <= R){
            	Power=add(freq,num,Power,currR);
            	currR++;
            }
            while (currR > R+1){
            	Power=remove(freq,num,Power,--currR);
            }
 
            ans[q.get(i).i]=Power;
        }
        return ans;
    }

	public static void main(String args[])throws IOException{
		InputReader sc=new InputReader(System.in);
		PrintWriter out=new PrintWriter(System.out);

		int n=sc.nextInt();
		int q=sc.nextInt();
		
		int[] num=sc.nextIntArray(n);
		ArrayList<Pair> query = new ArrayList<Pair>();
        Pair p;
		for(int i=0;i<q;i++) {
			p=new Pair( sc.nextInt()-1,sc.nextInt()-1 ,i);
			query.add(p);
		}
		long[] ans=queryResults(n,num,query,q);
		for(int i=0;i<q;i++)
			out.println(ans[i]);
		out.flush();
		out.close();
	}
}