The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai. 

Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.

Help the Little Elephant to count the answers to all queries.

Input

The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 ≤ lj ≤ rj ≤ n).

Output

In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query.

Examples

Input

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


Output

3
1
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;

public class Hello {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return str;
        }

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

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

        long nextLong() {

            return Long.parseLong(next());
        }

        BigInteger nextBigIntger() {
            BigInteger bb = new BigInteger(next());
            return bb;
        }
    }
    static int[] f = new int[100100];
    static int ans=0;
    public static void main(String args[]) {
        FastReader sc = new FastReader();
        int n = sc.nextInt(),m = sc.nextInt();
        int arr[] = new int[n+1];
        int[][] query = new int[m][3];
        int[] ans_arr = new int[m];
        for (int i=1;i<=n;i++)
            arr[i]=sc.nextInt();
        for (int i=0;i<m;i++){
            query[i][0]=sc.nextInt();
            query[i][1]=sc.nextInt();
            query[i][2]=i;
        }
        int block = (int)Math.sqrt(n);

        Arrays.sort(query, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0]/block !=o2[0]/block)
                    return o1[0]-o2[0];
                return o1[1]-o2[1];
            }
        });

        int l=1,r=n,index=l;
        while (index<=r){
            add(arr[index]);
            index++;
        }

        for (int i=0;i<m;i++){
            int L=query[i][0],R=query[i][1];
            while (r<R)add(arr[++r]);
            while (r>R)remove(arr[r--]);
            while (l<L)remove(arr[l++]);
            while (l>L)add(arr[--l]);
            ans_arr[query[i][2]]=ans;
//            System.out.println(ans);
        }

        for (int i=0;i<m;i++)
            System.out.println(ans_arr[i]);
    }
    public static void add(int x){
        if (x>=100100)return;
        if(f[x]==x)ans--;
        f[x]++;
        if (f[x]==x)ans++;
    }
    public static void remove(int x){
        if (x>=100100)return;
        if (f[x] !=0){
            if (f[x]==x)ans--;
            f[x]--;
            if (f[x]==x)ans++;
        }
    }

}

