Problem: The array a with n integers is given. Let's call the sequence of one or more consecutive elements in a segment. Also let's call the segment k-good if it contains no more than k different values.

Find any longest k-good segment.

As the input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.

Input

The first line contains two integers n, k (1 ≤ k ≤ n ≤ 5·105) — the number of elements in a and the parameter k.

The second line contains n integers ai (0 ≤ ai ≤ 106) — the elements of the array a.

Output

Print two integers l, r (1 ≤ l ≤ r ≤ n) — the index of the left and the index of the right ends of some k-good longest segment. If there are several longest segments you can print any of them. The elements in a are numbered from 1 to n from left to right.

Examples

Input

5 5
1 2 3 4 5


Output

1 5


Input

9 3
6 5 1 2 3 2 1 4 5


Output

3 7


Input

3 1
1 2 3


Output

1 1

Solution (in JAVA):

Solution:
import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class Solution {

    // Complete the hourglassSum function below.

    public static void main(String[] args) throws IOException {
    

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        
        String[] tmp = in.readLine().split(" ");
        int n = Integer.parseInt(tmp[0]);
         int k = Integer.parseInt(tmp[1]);
      
      tmp = in.readLine().split(" ");
      int[] a = new int[n+1];
        for(int i=1; i<=n; i++)
            a[i] = Integer.parseInt(tmp[i-1]);
        
        int p1 = 1;
        int p2 = 1;
        int st = 0;
        int ed = 0;
        
        HashSet<Integer> set = new HashSet<>();
        HashMap<Integer, Integer > map = new HashMap<>();
        int max = 0;
        int i;
        for( i=1; i<=n; i++)
        {
        
         
          
            int t = a[i];
            // pw.println(a[i]+" "+set.contains(t));
            
            set.add(t);
         //   pw.println(i+" "+a[i]+" "+map.get(t));
            if(map.get(t)!= null)
                map.put(t, map.get(t)+1);
            else
                map.put(t,  1);
            while(set.size()>k)
            {
                if(map.get(a[p2])>1)
                    map.put(a[p2], map.get(a[p2])-1);
                else
                {
                
                        map.remove(a[p2]);
                        set.remove(a[p2]);
                }
                    p2++;     
            }
         //   pw.println(p2);
           if(i - p2 + 1 >max && set.size()<=k){
           
            max =  i - p2+1;
            st = p2;
            ed = i;
        }
          
         //   pw.println(i+" "+p2+" "+set.size());
        }
        
          pw.println(st+" "+ed);

        pw.flush();
        pw.close();
    }

}