// Java implementation to find
// count of distinct elements
// in a range L to R for Q queries
import java.util.*;

public class Main {
    
    // Function to merge the right
    // and the left tree
    static void merge(List<Integer>[] tree, int treeNode){
        int len1 = tree[2 * treeNode].size();
        int len2 = tree[2 * treeNode + 1].size();
        int index1 = 0, index2 = 0;
        
        // Fill this array in such a
        // way such that values
        // remain sorted similar to mergesort
        while (index1 < len1 && index2 < len2) {
            
            // If the element on the left part
            // is greater than the right part
            if (tree[2 * treeNode].get(index1)
                > tree[2 * treeNode + 1].get(index2)) {
                tree[treeNode].add(
                    tree[2 * treeNode + 1].get(index2));
                index2++;
            }
            else {
                tree[treeNode].add(
                    tree[2 * treeNode].get(index1));
                index1++;
            }
        }
        
        // Insert the leftover elements
        // from the left part
        while (index1 < len1) {
            tree[treeNode].add(
                tree[2 * treeNode].get(index1));
            index1++;
        }
        // Insert the leftover elements
        // from the right part
        while (index2 < len2) {
            tree[treeNode].add(
                tree[2 * treeNode + 1].get(index2));
            index2++;
        }
    }
    
    // Recursive function to build
    // segment tree by merging the
    // sorted segments in sorted way
    static void build(List<Integer>[] tree, int[] arr, int start, int end,
                      int treeNode){
                          
        // Base case
        if (start == end) {
            tree[treeNode].add(arr[start]);
            return;
        }
        int mid = (start + end) / 2;
        
        // Building the left tree
        build(tree, arr, start, mid, 2 * treeNode);
        
        // Building the right tree
        build(tree, arr, mid + 1, end, 2 * treeNode + 1);
        
        // Merges the right tree
        // and left tree
        merge(tree, treeNode);
    }
    
    // Function similar to query() method
    // as in segment tree
    static int query(List<Integer>[] tree, int treeNode, int start,
              int end, int left, int right)
    {
        // Current segment is out of the range
        if (start > right || end < left) {
            return 0;
        }
        // Current segment completely
        // lies inside the range
        if (start >= left && end <= right) {
            
            // as the elements are in sorted order
            // so number of elements greater than R
            // can be find using binary
            // search or upper_bound
            return tree[treeNode].size()
               - Collections.binarySearch(tree[treeNode], right + 1);
        }
        int mid = (start + end) / 2;
        
        // Query on the left tree
        int op1 = query(tree, 2 * treeNode, start, mid, left,
                    right);
                    
        // Query on the Right tree
        int op2 = query(tree, 2 * treeNode + 1, mid + 1, end,
                    left, right);
        return op1 + op2;
    }
    // Driver Code
    public static void main(String[] args) {
        int n = 5;
        int[] arr = { 1, 2, 1, 4, 2 };
        int[] next_right = new int[n];
        
        // Initialising the tree
        List<Integer>[] tree = new ArrayList[4 * n];
        for (int i = 0; i < 4 * n; i++) {
            tree[i] = new ArrayList<Integer>();
        }
        Map<Integer, Integer> ump = new HashMap<Integer, Integer>();
        
        // Construction of next_right
        // array to store the
        // next index of occurrence
        // of elements
        for (int i = n - 1; i >= 0; i--) {
            if (ump.get(arr[i]) == null) {
                next_right[i] = n;
                ump.put(arr[i], i);
            }
            else {
                next_right[i] = ump.get(arr[i]);
                ump.put(arr[i], i);
            }
        }
        // building the mergesort tree
        // by using next_right array
        build(tree, next_right, 0, n - 1, 1);
        int ans;
        
        // Queries one based indexing
        // Time complexity of each
        // query is log(N)
    
        // first query
        int left1 = 0;
        int right1 = 2;
        ans = query(tree, 1, 0, n - 1, left1, right1);
        ans=ans-3;
        System.out.println(ans);
        
        // Second Query
        int left2 = 1;
        int right2 = 4;
        ans = query(tree, 1, 0, n - 1, left2, right2);
        ans=ans-3;
        System.out.println(ans);
    }
}
// This code is contributed by shiv1o43g