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


/**
 *
 * @author sarthak
 */

import java.util.*;
import java.math.*;
import java.io.*;

public class YandxALRn2_D {
    static int v=0;
    static class FastScanner {

        BufferedReader br;
        StringTokenizer st;

        public FastScanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }

        public String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
                return "";
            }
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
   
    static class P implements Comparable {

        private int x, y,in;

        public P(int x, int y,int in) {
            this.x = x;
            this.y = y;
            this.in=in;
        }

        public int hashCode() {
            return (x * 31) ^ y;
        }

        public boolean equals(Object o) {
            if (o instanceof P) {
                P other = (P) o;
                return (x == other.x && y == other.y);
            }
            return false;
        }

        public int compareTo(Object obj) {
            P l = (P) obj;
            if (this.x / v == l.x / v) {
                if (this.y == l.y) {
                    return 0;
                }
                return (this.y < l.y) ? -1 : 1;
            }
            return (this.x / v < l.x / v) ? -1 : 1;
        }
    }
    public static void main(String[] args) {

        FastScanner s = new FastScanner(System.in);
        StringBuilder op = new StringBuilder();
        int n = s.nextInt();
        int t = s.nextInt();
        int[] a=new int[n];
        for(int i=0;i<n;i++)
            a[i]=s.nextInt();
        v=(int)Math.sqrt(n);
        ArrayList<P> al=new ArrayList<>();
        for(int i=1;i<=t;i++)
        {
            int l=s.nextInt();l--;
            int r=s.nextInt();r--;
            al.add(new P(l,r,i));
        }
        Collections.sort(al);
        int cl=0;
        int cr=-1;
        int[] oc=new int[1000000+6];
        long an=0;
        long[] ANS=new long[t+1];
        for(P p:al){
            while(cl<p.x){
              an -= a[cl] * (2*oc[a[cl]] - 1);//remove
              oc[a[cl]]--;
              cl++;
            }
            while(cl>p.x){
                cl--;   //add
                an += a[cl] * (2*oc[a[cl]]  + 1);
                oc[a[cl]]++;
            }
            while(cr<p.y){
               cr++;
               an+=(2*oc[a[cr]]+1)*a[cr];
                oc[a[cr]]++;
              
            }
            while(cr>p.y){
              an-=(2*oc[a[cr]]-1)*a[cr];
              oc[a[cr]]--;
              
              cr--;
            }
            ANS[p.in]=an;
        }
        for(int i=1;i<=t;i++)
            op.append(ANS[i]+"\n");
           
        System.out.print(op);
        
        
        
        
        
        
        
        
        
        
        
    }

}
