We have N colored balls arranged in a row from left to right; the color of the i-th ball from the left is c_i.

You are given Q queries. The i-th query is as follows: how many different colors do the l_i-th through r_i-th balls from the left have?

Constraints

* 1\leq N,Q \leq 5 \times 10^5
* 1\leq c_i \leq N
* 1\leq l_i \leq r_i \leq N
* All values in input are integers.

Input

Input is given from Standard Input in the following format:


N Q
c_1 c_2 \cdots c_N
l_1 r_1
l_2 r_2
:
l_Q r_Q


Output

Print Q lines. The i-th line should contain the response to the i-th query.

Examples

Input

4 3
1 2 1 3
1 3
2 4
3 3


Output

2
3
1


Input

10 10
2 5 6 5 2 1 7 9 7 2
5 5
2 4
6 7
2 2
7 8
7 9
1 8
6 9
8 10
6 8


Output

1
2
2
1
2
2
6
3
3
3
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class Main {
    //Solution by Sathvik Kuthuru
    public static void main(String[] args) {
        FastReader scan = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        Task solver = new Task();
        int t = 1;
        for(int tt = 1; tt <= t; tt++) solver.solve(tt, scan, out);
        out.close();
    }

    static class Task {
        int n, q;
        int[] BIT, recent, a, ans;
        Query[] queries;

        public void solve(int testNumber, FastReader scan, PrintWriter out) {
            n = scan.nextInt();
            q = scan.nextInt();
            a = new int[n];
            recent = new int[n + 1];
            BIT = new int[n + 10];
            queries = new Query[q];
            ans = new int[q];

            for(int i = 0; i < n; i++) a[i] = scan.nextInt();
            for(int i = 0; i < q; i++) {
                queries[i] = new Query(scan.nextInt() - 1, scan.nextInt() - 1, i);
            }
            Arrays.sort(queries);
            Arrays.fill(recent, -1);
            int queryIndex = 0;
            for(int i = 0; i < n; i++) {
                if(recent[a[i]] != -1) update(recent[a[i]], -1);
                update(recent[a[i]] = i, 1);
                while(queryIndex < q && i == queries[queryIndex].right) {
                    ans[queries[queryIndex].index] = sum(i) - sum(queries[queryIndex].left - 1);
                    queryIndex++;
                }
            }
            for(int i : ans) out.println(i);
        }

        void update(int index, int val) {
            index++;
            for(; index < BIT.length; index += index & (-index)) BIT[index] += val;
        }

        int sum(int index) {
            index++;
            int ret = 0;
            for(; index > 0; index -= index & (-index)) ret += BIT[index];
            return ret;
        }

        static class Query implements Comparable<Query> {
            int left, right, index;

            public Query(int a, int b, int c) {
                left = a;
                right = b;
                index = c;
            }

            @Override
            public int compareTo(Query query) {
                return Integer.compare(right, query.right);
            }
        }

    }

    static void shuffle(int[] a) {
        Random get = new Random();
        for (int i = 0; i < a.length; i++) {
            int r = get.nextInt(a.length);
            int temp = a[i];
            a[i] = a[r];
            a[r] = temp;
        }
    }

    static void shuffle(long[] a) {
        Random get = new Random();
        for (int i = 0; i < a.length; i++) {
            int r = get.nextInt(a.length);
            long temp = a[i];
            a[i] = a[r];
            a[r] = temp;
        }
    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public FastReader(String s) throws FileNotFoundException {
            br = new BufferedReader(new FileReader(new File(s)));
        }

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

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

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

        double nextDouble() {
            return Double.parseDouble(next());
        }

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

}