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.BigInteger;
        import java.text.DecimalFormat;
        import java.util.*;

 
        
             public class Main {
            	public static InputReader in;
                public static PrintWriter pw;
             
             
             
            	public static void main(String args[]) 
            	{
            		new Thread(null, new Runnable() {
                        public void run() {
                            try{
                                solve();
                            }
                            catch(Exception e){
                                e.printStackTrace();
                            }
                        }
                    }, "1", 1 << 26).start();
                }
            	static ArrayList<Integer> g[];
            	static ArrayList<Integer> h[];
            	static boolean visited[];
            	static int[] parent;
            	static int par[];
            	static int degree[];
            	static int edjes=0;
            	static int start=-1;
            	static int end=-1;
            	static int Total=0;
            	static int time1[];
            	static int time2[];
            	static int glob=0;
            	static int[] ans;
            	static boolean vis2[][];
            	//static long sum1=0;
            	//static long val[];
                static ArrayList<Integer> levels[];
                static int max=0;
                static int lev=1;
                static ArrayList<Integer> nodes[];
                static ArrayList<Integer> values[];
                static int depth[];
                static boolean found=false;
               // static long sm[];
                static int sum1=0;
                static int pre[][];
                static int subtree[];
               static  int cnt=0;
               static  HashMap<String,Integer> hm;
               static int sm[];
               static int size[];
               static long mul[];
               static long d[]=new long[1000000];
               static int tot=0;
               static long highest=(long)1e9;
               static boolean bit=false;
                static Stack<Integer> tt=new Stack();
               static HashSet<Character> set;
         	   static long fact[],num[];
         	   static long MOD=1000000007;
         	   static int value[];static int premen[];
         	   static int count=0,index=0;
         	   static double ans11[];
         	   static int price[];
         	   static ArrayList<String> hp[][];
         	   static boolean visit[][];
         	   static int cnu[]=new int[1000001];
         	   static int label=1;
         	   static int his[][];
         	   static int size1=0;
         	   static int up[],down[];
         	   static int TotalUp=0;
         	   static long dist[];
         	//   static HashMap<String,Integer> hm1=new HashMap();
         	  // static HashMap<Integer,Integer> hm2=new HashMap();
         	   static TreeSet<Long> set1=new TreeSet();
         	  static  long DP[][][]=new long[20][200][1500];
         	 	static int t=-1,n=-1;
         	 	static int two[],min[],r[];
         	 	static int total[];static int black[];
         	 	static int Parent[];
         	 	static int max2[];
         	// 	static int tin[],tout[],a[];
         	 public static void solve() throws FileNotFoundException{
            		
            	
            		 in = new InputReader(System.in);
            		 pw = new PrintWriter(System.out);  
            	/*	 String p=in.readString();
            	     char c[]=p.toCharArray();
            	     int z[]=new int[p.length()];
            	     z[0]=0;
            	     int left=0;
            	     int right=0;
            	     for(int i=1;i<p.length();i++)
            	     {
            	    	 if(i>right)
            	    	 {
            	    		 
            	    		 left=right=i;
            	    		 while(right<p.length()&&c[right]==c[right-left])
            	    			 right++;
            	    		 z[i]=right-left;
            	    		 right--;
            	    	 }
            	    	 else
            	    	 {
            	    		 int k=i-left;
            	    		 if(z[k]<right-i+1)
            	    		 {
            	    			 z[i]=z[k];
            	    		 }
            	    		 else
            	    		 {
            	    			 left=i;
            	    			 while(right<p.length()&&c[right]==c[right-left])
                	    			 right++;
                	    		 z[i]=right-left;
                	    		 right--;
            	    		 }
            	    	 }
            	    	  
            	     }*/
            	   int n=in.nextInt();
            	   int k=in.nextInt();
            	   int a[]=in.nextIntArray(n);
            	   int l=0;
            	   int r=0;
            	   int z=0;
            	   int i=0;int j=0;
            	   HashSet<Integer> set=new HashSet();
            	   HashMap<Integer,Integer> hm=new HashMap();
            	   while(i<n)
            	   {
            		   while(hm.size()<=k&&i<n)
            		   {

            			   if(!hm.containsKey(a[i]))
            				   hm.put(a[i],1);
            			   else 
            				   hm.put(a[i],hm.get(a[i])+1);
            			   
            			   if(l<i-j&&hm.size()<=k)
            			   {
            				   l=i-j;
            				   z=i;r=j;
            			   }
            			   i++;
            		   }
            		   hm.put(a[j],hm.get(a[j])-1);
            		   if(hm.get(a[j])==0)
            			   hm.remove(a[j]);
            		   j++;
            	   }
            	   r++;z++;
            	   System.out.println(r+" "+(z));
                      
         	 } 
                     	 
         	 
         	 
                  	 public static int search(int l,int h,int a[],int key)
         	 {
         		 if(l>h)
         			 return -1;
         		 int mid=(l+h)/2;
         		 if(key==a[mid])
         		 {
         			 return mid;
         		 }
         		 if(a[l]<=a[mid])
         		 {
         			 if(key>=a[l]&&key<=a[mid])
         				 return search(l,mid-1,a,key);
         			 return search(mid+1,h,a,key);
         		 }
         		 if(key>=a[mid]&&key<=a[h])
         			 return search(mid+1,h,a,key);
         		 return search(l,mid-1,a,key);
         	 }
         	 public static boolean check(int a[][],int b[][],int n,int m)
         	 {
         		for(int k=0;k<n;k++)
    			{
    				for(int l=0;l<m;l++)
    				{
    					if(a[k][l]!=b[k][l])
    					{
    						return false;
    						//break;
    					}
    				}
    			}
         		return true;
         	 }
        
            
          		public static void bfs(int x)
         	 {
         		 visited[x]=true;
         		 Queue<Integer> Q=new LinkedList<Integer>();
         		 Q.add(x);
         		 while(!Q.isEmpty())
         		 {
         			 int count=Q.size();
         			 while(count>0)
         			 {
         				 int p=Q.poll();
         				 visited[p]=true;
         				 for(int y:g[p])
         				 {
         					 if(!visited[y])
         					 {
         						 Q.add(y);
         					 }
         				 }
         				 count--;
         			 }
         		 }
         	 }
         	 public static void depth(int curr,int parent)
         	 {
         		 visited[curr]=true;
         		 for(int x:g[curr])
         		 {
         			 if(!visited[x])
         			 {
         				 depth[x]=depth[curr]+1;
         				 depth(x,curr);
         			 }
         		 }
         	 }
         	
         	 static int Par[]=new int[202];
         	 public static void Height(int cur,int par){
         		 Par[cur]=par;
         		 visited[cur]=true;
         		 int t=0;
         		 for(int x:g[cur])
         		 {
         			 if(!visited[x])
         			 { 
         				 t++;
         				 Height(x,cur);
         				 high[cur]=Math.max(high[cur], high[x]+1);
         			 }
         		 }
         		 if(t==0)
         		 {
         			 high[cur]=0;
         		 }
         	
         	 }
         	 static int dia[]=new int[202];
         	 static int high[]=new int[292];
         	 public static void Diameter(int curr,int parent)
         	 {
         		visited[curr]=true;
         		int trees=0;
         		ArrayList<Integer> set=new ArrayList();
         	
         		for(int x:g[curr])
         		{
         			if(!visited[x])
         			{
         				trees++;
         				Diameter(x,curr);
         				dia[curr]=Math.max(dia[curr],high[x]);
         				set.add(high[x]);
         			}
         		}
         		if(set.size()>=2)
         		{
         			Collections.sort(set,Collections.reverseOrder());
         			dia[curr]=Math.max(dia[curr],set.get(0)+set.get(1)+2);
         		}
         		else if(set.size()>0)
         		{
         			dia[curr]=Math.max(dia[curr],set.get(0)+1);
         		}
         		if(trees==0)
         		{
         			dia[curr]=0;
         		}
         
         	 }
         	 
              	 
         	 public static boolean IsPal(String s)
         	 {
         		 char c[]=s.toCharArray();
         		 for(int i=0;i<c.length/2;i++)
         		 {
         			 if(c[i]!=c[s.length()-1-i])
         				 return false;
         		 }
         		 return true;
         	 }
         	public static void Merge(long[] a,int p,int r){
                if(p<r){
                    int q = (p+r)/2;
                    Merge(a,p,q);
                    Merge(a,q+1,r);
                    Merge_Array(a,p,q,r);
                }
            }
            public static void Merge_Array(long a[],int p,int q,int r){
               long b[] = new long[q-p+1];
                long c[] = new long[r-q];
                for(int i=0;i<b.length;i++)
                    b[i] = a[p+i];
                for(int i=0;i<c.length;i++)
                    c[i] = a[q+i+1];
                int i = 0,j = 0;
                for(int k=p;k<=r;k++){
                    if(i==b.length){
                        a[k] = c[j];
                        j++;
                    }
                    else if(j==c.length){
                        a[k] = b[i];
                        i++;
                    }
                    else if(b[i]<c[j]){
                        a[k] = b[i];
                        i++;
                    }
                    else{
                        a[k] = c[j];
                        j++;
                    }
                }
            }
         	 
         	 
         	 
         	
         	
               
         	  public static void dfs1(int curr,int parent)
         	  {
         		  visited[curr]=true;
         		  
         		  for(int x:g[curr])
         		  {
         			  
         			  if(x==parent)continue;
         			  depth[x]=depth[curr]+1;
         			  up[x]=up[curr];
         			  if(h[x].contains(curr)){
         				  up[x]++;
         				  TotalUp++;
         			  }
         			  dfs1(x,curr);
         		  }
         	  }
         	 
                
                
                public static void dfs(int curr,int Parent)
                {
                	visited[curr]=true;
                	size[curr]=1;
                	parent[curr]=Parent;
                	count++;
                	if(value[curr]>0)
                	{
                		index=value[curr];
                	}
                	for(int x:g[curr])
                	{
                		if(!visited[x])
                		{
                			dfs(x,curr);
                			size[curr]+=size[x];
                		}
                	}
                }
                static long ncr(long a, long b){
        			if(b>a || b<0) return 0;
        			long f = (fact[(int) a]*modInverse(((fact[(int) b]*fact[(int) (a-b)])%MOD), MOD))%MOD;
        			return f;
        		}
        		static long modInverse(long a, long mOD2){
                    return  power(a, mOD2-2, mOD2);
        }
        static long power(long x, long y, long m)
        {
            if (y == 0)
                return 1;
            long p = power(x, y/2, m) % m;
            p = (p * p) % m;
         
            return (y%2 == 0)? p : (x * p) % m;
        }
         
                public static long gcd(long x, long y) {
            		if (x == 0)
            			return y;
            		else
            			return gcd( y % x,x);
            	}	
                public static long power(long a,long b)
        		{
        			long result=1;
        			while(b>0)
        			{
        				if(b%2==1)
        					result*=a;
        				a=a*a;
        				b/=2;
        			}
        			return result;
        		}
                static class Pair implements Comparable<Pair>{
                	    int l;int r;long cost;
                		Pair(long val,int index,long cost){
                	     	this.l=(int) val;
                			this.r=index;
                			this.cost=cost;
                			
                		}
                		@Override
                		public int compareTo(Pair o) {
                                
                                	return r-o.r;
                		}
                				
                	}
            	static class InputReader {
             
            		private InputStream stream;
            		private byte[] buf = new byte[8192];
            		private int curChar, snumChars;
            		private SpaceCharFilter filter;
             
            		public InputReader(InputStream stream) {
            			this.stream = stream;
            		}
             
            		public int snext() {
            			if (snumChars == -1)
            				throw new InputMismatchException();
            			if (curChar >= snumChars) {
            				curChar = 0;
            				try {
            					snumChars = stream.read(buf);
            				} catch (IOException e) {
            					throw new InputMismatchException();
            				}
            				if (snumChars <= 0)
            					return -1;
            			}
            			return buf[curChar++];
            		}
             
            		public   int nextInt() {
            			int c = snext();
            			while (isSpaceChar(c))
            				c = snext();
            			int sgn = 1;
            			if (c == '-') {
            				sgn = -1;
            				c = snext();
            			}
            			int res = 0;
            			do {
            				if (c < '0' || c > '9')
            					throw new InputMismatchException();
            				res *= 10;
            				res += c - '0';
            				c = snext();
            			} while (!isSpaceChar(c));
            			return res * sgn;
            		}
             
            		public long nextLong() {
            			int c = snext();
            			while (isSpaceChar(c))
            				c = snext();
            			int sgn = 1;
            			if (c == '-') {
            				sgn = -1;
            				c = snext();
            			}
            			long res = 0;
            			do {
            				if (c < '0' || c > '9')
            					throw new InputMismatchException();
            				res *= 10;
            				res += c - '0';
            				c = snext();
            			} while (!isSpaceChar(c));
            			return res * sgn;
            		}
             
            		public int[] nextIntArray(int n) {
            			int a[] = new int[n];
            			for (int i = 0; i < n; i++)
            				a[i] = nextInt();
            			return a;
            		}
             
            		public String readString() {
            			int c = snext();
            			while (isSpaceChar(c))
            				c = snext();
            			StringBuilder res = new StringBuilder();
            			do {
            				res.appendCodePoint(c);
            				c = snext();
            			} while (!isSpaceChar(c));
            			return res.toString();
            		}
             
            		public boolean isSpaceChar(int c) {
            			if (filter != null)
            				return filter.isSpaceChar(c);
            			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
            		}
             
            		public interface SpaceCharFilter {
            			public boolean isSpaceChar(int ch);
            		}
            	}
            }