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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
import java.text.DecimalFormat;
import java.util.Iterator;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;

/**
 * Using FastReader and Output Class
 * 
 * @author Wallace
 */
 public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        RMQLCA solver = new RMQLCA();
        solver.solve(1, in, out);
        out.close();
    }

    static class  RMQLCA//it is for undirected graph
	{
        static int BLOCK_SIZE;
        static int frq[]=new int[1000001];
        static boolean isPre[];
        static  int a[];
        static long res=1;
		public void solve(int testNumber, FastReader in, PrintWriter out)			//main code
			{
                int n=in.nextInt();
                BLOCK_SIZE=(int)Math.sqrt(n)+2;
                int q=in.nextInt();
                a=in.nextIntArray(n);
                Query qq[]=new Query[q];
                for(int i=0;i<q;i++){
                    int l=in.nextInt();
                    int r=in.nextInt();
                    qq[i]=new Query(i,l,r);
                }
                Arrays.sort(qq, new Comparator<Query>() {
                    @Override
                    public int compare(Query p, Query q) {
                       int bucket1=p.l/BLOCK_SIZE,bucket2=q.l/BLOCK_SIZE;
                      // out.println(p+" "+bucket1+" "+q+" "+bucket2);
                       if(bucket1!=bucket2) return Integer.compare(bucket1, bucket2);
                       else if(bucket1%2==0) return Integer.compare(p.r, q.r);
                       else return -Integer.compare(p.r, q.r);
                    }
                });
                isPre=new boolean[n];
                Arrays.fill(frq,0);
                Arrays.fill(isPre,false);
                int ml=0,mr=0;
                res=0;
                helper(0);
                
               // out.println("hahah "+res);
                for(int i=0;i<q;i++){
                    int ql=qq[i].l-1,qr=qq[i].r-1;
                    while(mr<qr){
                        helper(++mr);
                    }
                    while(ml>ql){
                        helper(--ml);
                    }
                    while(mr>qr){
                        helper(mr--);
                    }
                    while(ml<ql){
                        helper(ml++);
                    }
                   // out.println(i+" "+ql+" "+qr+" "+res+" "+ml+" "+mr);
                    qq[i].ans=res;
                }

                Arrays.sort(qq,(x,y)->x.i-y.i);
                for(int i=0;i<q;i++){
                    out.println(qq[i].ans);
                }
                    
            }
        public static void helper(long index){
          //  System.out.println(index);
            if(isPre[(int)index]){
                long tmp=frq[(int)a[(int)index]];
                long tmp1=tmp*tmp*a[(int)index];
                res=res-tmp1;
                frq[(int)a[(int)index]]--;
                tmp1=(tmp-1)*(tmp-1)*a[(int)index];
                res=res+tmp1;
                isPre[(int)index]=false;
            }else{
                long tmp=frq[(int)a[(int)index]];
                long tmp1=tmp*tmp*a[(int)index];
                res=res-tmp1;
                frq[(int)a[(int)index]]++;
                tmp1=(tmp+1)*(tmp+1)*a[(int)index];
                res=res+tmp1;
                isPre[(int)index]=true;
            }
        }
        
    
            
        static class Query{
            int i,l,r;
            long ans;
         public   Query(int i,int l, int r){
                this.l=l;
                this.r=r;
                this.i=i;
            }

            @Override
            public String toString() {
                return "Query [ans=" + ans + ", i=" + i + ", l=" + l + ", r=" + r + "]";
            }
        }
         
	}

 //for the fastreader
    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar;
        private int pnumChars;

        public FastReader(InputStream stream) {
            this.stream = stream;
        }
        public long gcd(long a, long b) {
            return b == 0 ? a : gcd(b, a % b);
        }
     
        public int gcd(int a, int b) {
            return b == 0 ? a : gcd(b, a % b);
        }

        public long pow(long base, long exp, long MOD) {
            base %= MOD;
            long ret = 1;
            while (exp > 0) {
                if ((exp & 1) == 1) ret = ret * base % MOD;
                base = base * base % MOD;
                exp >>= 1;
            }
            return ret;
    
        }
 
        private int pread() {
            if (pnumChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= pnumChars) {
                curChar = 0;
                try {
                    pnumChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (pnumChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }
 
        public int nextInt() {
            int c = pread();
            while (isSpaceChar(c))
                c = pread();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = pread();
            }
            int res = 0;
            do {
                if (c == ',') {
                    c = pread();
                }
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = pread();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
 
	public String next() {
            return nextString();
        }
	
	 public String nextString() {
            int c = pread();
            while (isSpaceChar(c))
                c = pread();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = pread();
            } while (!isSpaceChar(c));
            return res.toString();
        }
	
	public long[] nextLongArray(int n) {
            long[] array = new long[n];
            for (int i = 0; i < n; i++) {
                array[i] = nextLong();
            }
            return array;
        }
	
	public double[] nextDoubleArray(int n) {
            double[] array = new double[n];
            for (int i = 0; i < n; i++) {
                array[i] = nextDouble();
            }
            return array;
        }
 
	public int[] nextIntArray(int n) {
            int[] array = new int[n];
            for (int i = 0; i < n; i++) {
                array[i] = nextInt();
            }
            return array;
        }
 
        public long nextLong() {
            int c = pread();
            while (isSpaceChar(c))
                c = pread();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = pread();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = pread();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
 
	 public double nextDouble() {
            int c = pread();
            while (isSpaceChar(c))
                c = pread();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = pread();
            }
            double res = 0.0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = pread();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
 
      
 
        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
 
    }
 
 
}
