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

public class Main {
    
    public static void main(String[] args) throws IOException {
        PrintWriter out = new PrintWriter(System.out);
        FastReader in = new FastReader(new BufferedReader(new InputStreamReader(System.in)));
        Task solver = new Task();
        solver.solve(in, out);
        out.close();
    }
    
}

class Task {
    
    boolean fnd(int a, int b) {
        String aa = Integer.valueOf(a).toString(), 
                bb = Integer.valueOf(b).toString();
        for(char c = '0'; c <= '9'; ++c) {
            if(aa.indexOf(c) != -1 && bb.indexOf(c) != -1) {
                return true;
            }
        }
        return false;
    }
    
    public void solve(FastReader in, PrintWriter out) throws IOException {
 
        int n = in.nextInt(), q = in.nextInt();
        int a[] = new int[n], ans[] = new int[q];
        int cnt[] = new int[n + 1], sum[] = new int[n];
        int l[] = new int[q], r[] = new int[q];
        for(int i = 0; i < n; ++i) {
            a[i] = in.nextInt();
            if(a[i] <= n) ++cnt[a[i]];
        }
        for(int i = 0; i < q; ++i) {
            l[i] = in.nextInt();
            r[i] = in.nextInt();
        }
        for(int i = 1; i <= n; ++i) {
            if(cnt[i] >= i) {
                sum[0] = (a[0] == i ? 1 : 0);
                for(int j = 1; j < n; ++j) {
                    sum[j] = sum[j - 1] + (a[j] == i ? 1 : 0);
                }
                for(int j = 0; j < q; ++j) {
                    int have = sum[r[j] - 1];
                    if(l[j] > 1) have -= sum[l[j] - 2];
                    if(have == i) ++ans[j];
                }
            }
        }
        for(int i = 0; i < q; ++i) {
            out.println(ans[i]);
        }
    }
    
}

class FastReader {
    
    BufferedReader in;
    StringBuilder sb = new StringBuilder();
    
    public FastReader(BufferedReader in) {
        this.in = in;
    }
    
    public String next() throws IOException {
        sb.setLength(0);
        while(true) {
            int c = in.read();
            if(c == -1) {
                return null;
            }
            if(" \n\r\t".indexOf(c) == -1) {
                sb.append((char)c);
                break;
            }
        }
        while(true) {
            int c = in.read();
            if(c == -1 || " \n\r\t".indexOf(c) != -1) {
                break;
            }
            sb.append((char)c);
        }
        return sb.toString();
    }
    
    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }
    
    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }
    
    public double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
    
}
