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.BufferedInputStream;
import java.io.InputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.*;


public class Main {

  public static void main(String[] args) {
    ScanReader scanner = new ScanReader(System.in);
    int N = scanner.nextInt();
    int T = scanner.nextInt();
    int[] A = new int[N];
    for (int i = 0; i < N; i++) {
      A[i] = scanner.nextInt();
    }
    int[][] Q = new int[T][3];
    for (int i = 0; i < T; i++) {
      Q[i][0] = scanner.nextInt() - 1;
      Q[i][1] = scanner.nextInt();
      Q[i][2] = i;
    }
    solve(T, A, Q);
  }

  final static int MAXV = 1000005;
  static long[] count = new long[MAXV];
  static long curAns = 0L;

  public static void add(int num) {
    curAns -= count[num] * count[num] * num;
    count[num] += 1;
    curAns += count[num] * count[num] * num;
  }

  public static void remove(int num) {
    curAns -= count[num] * count[num] * num;
    count[num] -= 1;
    curAns += count[num] * count[num] * num;
  }

  public static void solve(int T, int[] A, int[][] Q) {
    int M = 1000;
    Arrays.sort(Q, (a, b) -> {
      if (a[0] / M != b[0] / M) {
        return a[0] / M - b[0] / M;
      }
      return a[1] - b[1];
    });

    long[] ans = new long[T];
    int left = 0;
    int right = 0;
    for (int i = 0; i < T; i++) {
      int l = Q[i][0];
      int r = Q[i][1];
      int qi = Q[i][2];
      while (left < l) remove(A[left++]);
      while (left > l) add(A[--left]);
      while (right < r) add(A[right++]);
      while (right > r) remove(A[--right]);

      ans[qi] = curAns;
    }

    PrintWriter out = new PrintWriter(System.out);
    for (int i = 0; i < T; i++) {
      out.println(ans[i]);
    }
    out.close();
  }

  static class ScanReader {
    private byte[] buf = new byte[4 * 1024];
    private int index;
    private BufferedInputStream in;
    private int total;

    public ScanReader(InputStream inputStream) {
      in = new BufferedInputStream(inputStream);
    }

    private int scan() {
      if (index >= total) {
        index = 0;
        try {
          total = in.read(buf);
        } catch (Exception e) {
          e.printStackTrace();
        }
        if (total <= 0) return -1;
      }
      return buf[index++];
    }

    public int nextInt() {
      int integer = 0;
      int n = scan();
      while (isWhiteSpace(n)) n = scan();
      int neg = 1;
      if (n == '-') {
        neg = -1;
        n = scan();
      }
      while (!isWhiteSpace(n)) {
        if (n >= '0' && n <= '9') {
          integer *= 10;
          integer += n - '0';
          n = scan();
        }
      }
      return neg * integer;
    }

    private boolean isWhiteSpace(int n) {
      if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1) return true;
      else return false;
    }

  }
}

class UnioinSet {
  private Map<Long, Long> parents = new HashMap<>();

  public Long find(Long u) {
    if (parents.getOrDefault(u, u).equals(u)) {
      return u;
    }

    return find(parents.get(u));
  }

  public void union(Long u, Long v) {
    Long pu = find(u);
    Long pv = find(v);

    parents.put(pu, pv);
  }
}

class Pair implements Comparable<Pair> {
  public int x;
  public int y;

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

  public int toIndex(int base) {
    return this.x * base + this.y;
  }

  public List<Pair> neighbors() {
    List<Pair> ans = new ArrayList<>();
    ans.add(new Pair(this.x + 1, this.y));
    ans.add(new Pair(this.x - 1, this.y));
    ans.add(new Pair(this.x, this.y + 1));
    ans.add(new Pair(this.x, this.y - 1));

    return ans;
  }

  @Override
  public int compareTo(Pair o) {
    if (o.x != this.x) {
      return this.x - o.x;
    } else {
      return this.y - o.y;
    }
  }

  @Override
  public int hashCode() {
    int v = this.x * 100000 + this.y;
    return Integer.hashCode(v);
  }

  @Override
  public boolean equals(Object obj) {
    if (obj == this) {
      return true;
    }
    if (obj instanceof Pair) {
      Pair op = (Pair) obj;
      return op.x == this.x && op.y == this.y;
    }

    return false;
  }
}
