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.util.*;



import java.io.*;
import java.lang.*;
import java.security.KeyStore.Entry;
public class Q2 {

	static ArrayList<Integer> adj[];
	static int color[],red[],black[],previs[];
	static boolean b[],visited[],possible;
	static Map<Long,Long> dict;
	static int totalnodes,colored,time,v[],l[],r[];
	//static int p[];
	static  HashMap<Integer,int[]> hm;//static 
	//static boolean[] isPrime=new boolean[N];
	//static int[] Primefact=new int[N];
	 static int[] init,goal;
	 static ArrayList<Integer> res;
	 
	void solve(){
		in=new InputReader(System.in);
		w=new PrintWriter(System.out);
	int n=in.nextInt();
	int k=in.nextInt();
	int a[]=new int[n+1];
	int f[]=new int[1000007];
	for(int i=1;i<=n;i++)
	{
		a[i]=in.nextInt();
	}
	int mi=-1;
	int mj=-1;
	int mg=0;
	//int hs[]=new int[1000007];
		int j=1;
		int cur=0;
		for(int i=1;i<=n;i++)
		{
			while(j<=n)
			{
				if(++f[a[j]]==1)
					cur++;
				
				if(cur>k)
				{
					if(--f[a[j]]==0)
						cur--;
					break;
				}
				j++;
			}
			if(mj-mi<j-i)
			{
				mi=i;
				mj=j;
			}
			if(--f[a[i]]==0)
				cur--;
			
		}
		w.println(mi+" "+(mj-1));
		w.close();
					
	}
	
	public static void main(String[] args) throws IOException{
		new Q2().solve();
	}
	 void seive(int N){
		//isPrime = new boolean[(int) (n+1)];
		
		
		}
	int modularExponentiation(int x,int n,int M)
	{
	    if(n==0)
	        return 1;
	    else if(n%2 == 0)        //n is even
	        return modularExponentiation((x*x)%M,n/2,M);
	    else                             //n is odd
	        return (x*modularExponentiation((x*x)%M,(n-1)/2,M))%M;

	}
	void dfs(int x,int even,int odd,int level,int parent)
	{
		if(level%2==0 && even%2==1 || level%2==1 && odd%2==1  )
		{
			if(init[x]==1)
				init[x]=0;
			else
				init[x]=1;
		}
		if(init[x]!=goal[x])
			res.add(x);
		for(int i:adj[x])
		{
			if(i!=parent)
			{
				if(init[x]!=goal[x])
				{
					if(level%2==0)
					{
						dfs(i,even+1,odd,level+1,x);
					}
					else
					{
						dfs(i,even,odd+1,level+1,x);
					}
				}
				else
				{
					dfs(i,even,odd,level+1,x);
				}
			}
		}
	}
/*	void dfs(int u,int low,int high)
	{
		if(u==-1 || low>high)
			return;
		if(low<=v[u] && v[u]<=high){
		hm.put(v[u],true);
		}
		dfs(l[u],low,high<v[u]-1?high:v[u]-1);
		dfs(r[u],low>v[u]+1?low:v[u]+1,high);
		
	}
	
	  int dfs_red(int i)
	{
		previs[i]=time++;
		visited[i]=true;
		if(color[i]==0)
			red[i]++;
		for(int j:adj[i])
		{
			if(!visited[j])
				red[i]+=dfs_red(j);
		}
		return red[i];
	}
	 int dfs_black(int i)
	{
		
		visited[i]=true;
		if(color[i]==1)
			black[i]++;
		for(int j:adj[i])
		{
			if(!visited[j])
				black[i]+=dfs_black(j);
		}
		return black[i];
	}*/
	
	
	 public static class dsu
		{
			 
			int n;
			int parent[];
		    int s[];
			dsu(int n)
			{
				this.n=n;
				parent=new int[n+1];
				s=new int[n+1];
		        for(int i=0;i<=n;i++)
		        {
		            parent[i]=i;
		            s[i]=1;
		        }
			}
		 int find(int i)
		{
		    if (parent[i] == i)
		        return i;
		    else
		    {
		    	int result = find(parent[i]);
		        parent[i] = result;
		        return result;
		     }
		}
		}
	static InputReader in;
	static PrintWriter w;
	public boolean oj = System.getProperty("ONLINE_JUDGE") != null;

	public void tr(Object... o) {
		if (!oj)
			System.out.println(Arrays.deepToString(o));
	}

	
	public static long power(long a,long b,long c)
	{
		long ans = 1;
		while(b!=0)
		{
			if(b%2==1)
			{
				ans = ans*a;
				ans = ans % c;
			}
			a = a*a;
			a = a%c;
			b = b/2;
		}
		return ans;
	}
	static class Pair implements Comparable<Pair> {
		int i,x,w;
		
		public Pair(){
			
		}
		public Pair(int u,int v) {
			this.i=u;
			this.x=v;
			this.w=Math.min(u, v);
			
		}
		public int compareTo(Pair other) {
			
			return 0;
		}
		
		/*public String toString() {
			return "[u=" + u + ", v=" + v + "]";
		}*/
	}
	static class Node2{
		Node2 left = null;
		Node2 right = null;
		Node2 parent = null;
		int data;
	}
	
	//binaryStree
	static class BinarySearchTree{
		Node2 root = null;
		int height = 0;
		int max = 0;
		int cnt = 1;
		ArrayList<Integer> parent = new ArrayList<>();
		HashMap<Integer, Integer> hm = new HashMap<>();
		public void insert(int x){
			Node2 n = new Node2();
			n.data = x;
			if(root==null){
				root = n;
			}
			else{
				Node2 temp = root,temp2 = null;
				while(temp!=null){
					temp2 = temp;
					if(x>temp.data) temp = temp.right;
					else temp = temp.left;
				}
				if(x>temp2.data) temp2.right = n;
				else temp2.left = n;
				n.parent = temp2;
				parent.add(temp2.data);
			}
		}
		public Node2 getSomething(int x, int y, Node2 n){
			if(n.data==x || n.data==y) return n;
			else if(n.data>x && n.data<y) return n;
			else if(n.data<x && n.data<y) return getSomething(x,y,n.right);
			else return getSomething(x,y,n.left);
		}
		public Node2 search(int x,Node2 n){
			if(x==n.data){
				max = Math.max(max, n.data);
				return n;
			}
			if(x>n.data){
				max = Math.max(max, n.data);
				return search(x,n.right);
			}
			else{
				max = Math.max(max, n.data);
				return search(x,n.left);
			}
		}
		public int getHeight(Node2 n){
			if(n==null) return 0;
			height = 1+ Math.max(getHeight(n.left), getHeight(n.right));
			return height;
		}
	}
public static void debug(Object... o) {
	System.out.println(Arrays.deepToString(o));
}

public static String rev(String s)
{
	StringBuilder sb=new StringBuilder(s);
	sb.reverse();
	return sb.toString();
}

static long lcm(long a, long b)
{
    return a * (b / gcd(a, b));
}

static long gcd(long a, long b)
{
    while (b > 0)
    {
        long temp = b;
        b = a % b; // % is remainder
        a = temp;
    }
    return a;
}

public static long max(long x, long y, long z){
		if(x>=y && x>=z) return x;
		if(y>=x && y>=z) return y;
		return z;
	}
	static int[] sieve(int n,int[] arr)
	{
	for(int i=2;i*i<=n;i++)
	{
		if(arr[i]==0)
		{
			for(int j=i*2;j<=n;j+=i)
				arr[j]=1;
		}
	}
	return arr;
	}




static class InputReader {

private final InputStream stream;
private final 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) {
	 return nextIntArray(n, 0);
	    }
	    
public int[] nextIntArray(int n, int off) {
	 int[] arr = new int[n + off];
	   for (int i = 0; i < n; i++) {
	    arr[i + off] = nextInt();
	    }
	    return arr;
	    }
	    
public long[] nextLongArray(int n) {
return nextLongArray(n, 0);
	    }
        
	public long[] nextLongArray(int n, int off) {
	 long[] arr = new long[n + off];
	 for (int i = 0; i < n; i++) {
		  arr[i + off] = nextLong();
		 }
 return arr;
	}


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 String nextLine() {
  int c = snext();
  while (isSpaceChar(c))
    c = snext();
  StringBuilder res = new StringBuilder();
  do {
    res.appendCodePoint(c);
    c = snext();
  } while (!isEndOfLine(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;
}

private boolean isEndOfLine(int c) {
  return c == '\n' || c == '\r' || c == -1;
}

public interface SpaceCharFilter {
  public boolean isSpaceChar(int ch);
}
}
	
}