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.awt.*;
import java.io.*;
import java.util.*;

public class Abc {
    public static void main(String[] args) throws Exception {
        FastReader sc = new FastReader();
        int n=sc.nextInt(),m=sc.nextInt();
        int arr[]=new int[n+1];
        Map<Integer,Integer> map=new HashMap<>();
        int c=-1;
        int cnt[]=new int[n+1];
        for (int i=1;i<=n;i++){
            arr[i]=sc.nextInt();
            if (arr[i]>n)continue;
            cnt[arr[i]]++;
        }
        for (int i=1;i<=n;i++){
            if (arr[i]>n)continue;
            if (cnt[arr[i]]<arr[i])continue;
            if (!map.containsKey(arr[i]))map.put(arr[i],++c);
        }
        int pre[][]=new int[c+1][n+1];
        int tmp[]=new int[c+1];
        for (int i:map.keySet()){
            int ind=map.get(i);
            tmp[ind]=i;
            for (int j=1;j<=n;j++){
                pre[ind][j]=pre[ind][j-1]+(arr[j]==i?1:0);
            }
        }
        StringBuilder sb=new StringBuilder();
        while (m-->0){
            int ans=0;
            int l=sc.nextInt(),r=sc.nextInt();
            for (int i=0;i<=c;i++){
                if (pre[i][r]-pre[i][l-1]==tmp[i])ans++;
            }
            sb.append(ans+"\n");
        }
        System.out.print(sb);

    }
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

        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;
        }
    }
}