There are quite a lot of ways to have fun with inflatable balloons. For example, you can fill them with water and see what happens.

Grigory and Andrew have the same opinion. So, once upon a time, they went to the shop and bought n packets with inflatable balloons, where i-th of them has exactly a_i balloons inside.

They want to divide the balloons among themselves. In addition, there are several conditions to hold:

  * Do not rip the packets (both Grigory and Andrew should get unbroken packets); 
  * Distribute all packets (every packet should be given to someone); 
  * Give both Grigory and Andrew at least one packet; 
  * To provide more fun, the total number of balloons in Grigory's packets should not be equal to the total number of balloons in Andrew's packets. 



Help them to divide the balloons or determine that it's impossible under these conditions.

Input

The first line of input contains a single integer n (1 ≤ n ≤ 10) — the number of packets with balloons.

The second line contains n integers: a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000) — the number of balloons inside the corresponding packet.

Output

If it's impossible to divide the balloons satisfying the conditions above, print -1.

Otherwise, print an integer k — the number of packets to give to Grigory followed by k distinct integers from 1 to n — the indices of those. The order of packets doesn't matter.

If there are multiple ways to divide balloons, output any of them.

Examples

Input

3
1 2 1


Output

2
1 2


Input

2
5 5


Output

-1


Input

1
10


Output

-1

Note

In the first test Grigory gets 3 balloons in total while Andrey gets 1.

In the second test there's only one way to divide the packets which leads to equal numbers of balloons.

In the third test one of the boys won't get a packet at all.
 import java.io.*;
    import java.util.*;
  
 
  
        public class Codeforces {
    	
    		   public static long log2(long x)
    			{
    				long p=1;
    				long ans=0;
    				while(x>=p)
    				{
    					p*=2;
    					ans++;
    				}
    				return ans-1;
    			}
    		   
    		   
    		   public static void extendedgcd(int a, int b)
    		   {
    			   x=0;
    			   y=0;
    			   gc=0;
    			   xgcd(a,b);
    			   pw.println(a+"*"+x+" + "+b+"*"+y+" = "+gc);
    			   
    		   }
    		   
    		   
    		   public static long modex(long a, long b, long c)
    		   {
    			   if(b==0)
    				   return 1;
    			   else if(b==1)
    				   return a%c;
    			   else if(b%2==0)
    			   {
    				   	return modex((a*a)%c,b/2,c);
    			   }
    			   else
    			   {
    				   return (a*modex((a*a)%c,b/2,c))%c;
    				   
    			   }
    			   
    			   
    		   }
    		   
    		   
    		   public static void xgcd(int a, int b)
    		   {
    			   
    			   if(b==0)
    			   {
    				   x=1;
    				   y=0;
    				   gc=a;
    				   
    				   
    			   }
    			   else
    			   {
    				   xgcd(b,a%b);
    				   int temp = x;
    				   x=y;
    				   y = temp - ((a/b)*y);
    				   
    			   }
    		   }
    		   
    		   public static long gcd(long a, long b)
    		   {
    			   if(b==0)return a;
    			   else return gcd(b,a%b);
    			   
    		   }
    		   
    		   static int x,y,gc;
    		   
    		  
    		
    		   
    		   static HashSet<Character> set;
    		   
    		   
    		   
    		   public static long expmod(long a, long b, long mod)
    		   {
    			   if(b==0)return 1;
    			   if(b==1)return a;
    			   
    			   if(b%2==0)
    			   {
    				   return ((expmod(a,b/2,mod)%mod)*(expmod(a,b/2,mod)%mod))%mod;
    			   }
    			   else
    			   {
    				   return ((a%mod)*(expmod(a,b/2,mod)%mod)*(expmod(a,b/2,mod)%mod))%mod;
    			   }
    		   }
    		   
    		   static class Comp implements Comparator<Point>
    		   {

				@Override
				public int compare(Point arg0, Point arg1) {
					
					if(arg0.x>arg1.x)return 1;
					if(arg0.x<arg1.x)return -1;
					return 0;
				}
    			   
    		   }
    		   
    		   
    		   static class STComp implements Comparator<Integer>
    		   {

				@Override
				public int compare(Integer arg0, Integer arg1) {
					
					return arg0.compareTo(arg1); 
				}
    			   
    		   }
    		   
    		   static class Point
    		   {
    			   int x,y,ind;
    			   
    			    public Point(int a, int b)
    			    {
    			    	x=a;
    			    	y=b;
    			    	ind=0;
    			    }
    			   
    			    
    		   }
    		   
    		 
    		   
    		  
    		   
    		   public static boolean issub(String s1, String s2)
    		   {
    			   if(s1.length()>s2.length())
    			   return false;
    			   
    			   int l1 = s1.length();
    			   int l2 = s2.length();
    			   
    			   
    			   for(int i=0;i<=l2-l1;i++)
    			   {
    				   String sub = s2.substring(i, i+l1);
    				   if(s1.equals(sub))return true;
    			   }
    			   
    			   return false;
    		   }
    		   
    		   
    		   
    		   public static String enc(String s, int n)
    		   {
    			   String s1 = s.substring(0,n);
    			   String s2 = s.substring(n, s.length());
    			   
    			  String re="";
    			  for(int i=s1.length()-1;i>=0;i--)re+=s1.charAt(i);
    			  
    			  return re+s2;
    			   
    			   
    			   
    		   }
    		 
    		   
    		   
    		   static int vis[];
    		   
    		   public static void dfs(int x)
    		   {
    			   vis[x]=1;
    			   
    			   ArrayList<Integer> li = adj[x];
    			   
    			   for(int ch:li)
    			   {
    				   
    				   if(vis[ch]==0)dfs(ch);
    				   
    			   }
    			   
    		   }
    		   /*
    		   public static void dfsm(int x, HashSet<Integer> set)
    		   {
    			   vis2[x]=1;
    			   
    			   ArrayList<Integer> li = adj[x];
    			   
    			   for(int ch:li)
    			   {
    				   //if(!set.contains(ch))continue;
    				   if(vis2[ch]==0)dfsm(ch,set);
    				   
    			   }
    			   
    		   }
    		   */
    		   
    		  
    		
    		   public static void countPaths(int s, int d, ArrayList<Integer> pa)
    		   {
    			   
    			   vis2[s]=1;
    			   if(s==d)
    			   {
    				   pa.add(s);
    				 //  paths[ct] = new ArrayList<Integer>(pa);
    				   ct++;
    			   }
    			   else
    			   {
    				   ArrayList<Integer> li = adj[s];
    				   pa.add(s);
    				   
    				   for(int ad: li)
    				   {
    					   if(vis2[ad]==0)countPaths(ad,d,pa);
    				   }
    				   
    				   
    			   }
    			   
    			   if(pa.size()>1)pa.remove(pa.size()-1);
    			   vis2[s]=0;
    			   return ;
    		   }
    		  
    		   
    		   
    		   public static boolean dif(String s1, String s2)
    		   {
    			   int ct=0;
    			   if(s1.length()!=s2.length())return false;
    			   for(int i=0;i<s1.length();i++)
    			   {
    				   if(s1.charAt(i)!=s2.charAt(i))ct++;
    				   
    			   }
    			   
    			   if(ct==1)return true;
    			   else return false;
    			   
    			   
    		   }
    		   
    		   
    		   
    		   
    		   static void add(int arr[], int N, int lo,
                       int hi, int val)
    		   {
							    arr[lo] += val;
							    if (hi != N - 1)
							       arr[hi + 1] -= val;
    		   }
 
// Utility method to get actual array from 
// operation array
static void updateArray(int arr[], int N)
{
    // convert array into prefix sum array
    for (int i = 1; i < N; i++)
        arr[i] += arr[i - 1];
}
  
// method to print final updated array
static void printArr(int arr[], int N)
{
    updateArray(arr, N);
    for (int i = 0; i < N; i++)
        System.out.print(""+arr[i]+" ");
    System.out.print("\n");
}
  
    		   
  
    		  static int cyc;
    		   
    		   
    		  
    		  public static void dfsmod(int v, HashSet<Integer> set)
    		  {
    			  vis2[v]=1;
    			  
    			  ArrayList<Integer> li = adj[v];
    			  
    			  set.add(v);
    			  
    			  for(int ch: li)
    			  {
    				  if(set.contains(ch))
    				  {
    					  cyc=1;
    					  pw.println("** "+ch+" "+v);
    				  }
    				  if(vis2[ch]==0)dfsmod(ch,set);
    				  
    			  }
    			  
    			  set.remove(v);
    			  
    			  
    		  }
    		  
    		  
    		  	public static boolean isps(int x)
    		  	{
    		  		int sq = (int)Math.sqrt(x);
    		  		
    		  		return sq>0&&sq*sq==x;
    		  		
    		  		
    		  		
    		  		
    		  		
    		  		
    		  		
    		  		
    		  		
    		  	}
    		  
    		  	 public static void combinations(String suffix,String prefix)
    		  	 {
    		         if(prefix.length()<0)return;
    		         pw.println(suffix);
    		        	 
    		        	 
    		         for(int i=0;i<prefix.length();i++)
    		          combinations(suffix+prefix.charAt(i),prefix.substring(i+1,prefix.length()));
    		         
    		     }
    		  	
    		  	
    		  	 
    		
    		  	 
    		  	 
    		  	 public static void topo(int x)
    		  	 {
    		  		 vis2[x]=1;
    		  		// pw.println("vis "+x);
    		  		 ArrayList<Integer> li = adj[x];
    		  		// pw.println(x+" has siz "+li.size());
    		  		// Integer i = x;
    		  		 for(int ch: li)
    		  		 {
    		  			
    		  			 if(vis2[ch]==0)
    		  				 {topo(ch);
    		  				//pw.println(x+" "+ch);
    		  				 }
    		  		 }
    		  		 
    		  		 st.push(x);
    		  		 //pw.println(i+" pushed");
    		  	 }
    		  	 
    		  	 
    	  		   

    		 	static  ArrayList<Integer>[] adj;
    		 	static int[] vis2;
    		 	static int ct;

    		     public static void ch(Stack<Integer> s)
    		     {
    		    	 s.push(4);
    		    	 return;
    		     }
    		     
    		     static Stack<Integer> st;
    		     
    		     
    		     static class PQnode implements Comparable<PQnode>
    		     {
    		    	 int value;
    		    	 int distance;
    		    	 
    		    	 public PQnode(int x, int y)
    		    	 {
    		    		 value=x;
    		    		 distance=y;
    		    	 }

					@Override
					public int compareTo(PQnode o) {
					return Integer.compare(this.distance, o.distance);
						
					
					
					}
					
					
					  @Override
		    		    public  boolean equals(Object o)
		    		    {
		    		    	if(o==this)return true;
		    		    	
		    		    	if(!(o instanceof PQnode))
		    		    	{
		    		    		return false;
		    		    	}
		    		    	
		    		    	PQnode node = (PQnode) o;
		    		    	
		    		    	return value==node.value&&distance==node.distance;
		    		    	
		    		    }
    		     }
    		  
    		  
    		     static class Compq implements Comparator<PQnode>
    		     {

					
					public int compare(PQnode arg0, PQnode arg1) {
						
						if(arg0.distance>arg1.distance)return 1;
						if(arg0.distance<arg1.distance)return -1;
						return 0;
					}
    		    	 
    		    	 
    		    	 
    		     }
    		     
    		     public static void printpa(int pa[],int x)
    		     {
    		    	 if(pa[x]==-1)
    		    		 
    		    		 pw.println(x);
    		    	 else
    		    	 {
    		    		 printpa(pa, pa[x]);
    		    		 pw.println(x);
    		    	 }
    		     }
    		     
    		     
    		  	 public static void main(String[] args) 
    	   {
    		  		 int n = sc.nextInt();
    		  		 
    		  		 int arr[] = new int[n];
    		  		 
    		  		 for(int i=0;i<n;i++)arr[i]=sc.nextInt();
    		  		 
    		  		 if(n==1)
    		  		 {
    		  			 pw.println(-1);
    		  			 pw.close();
    		  			 return;
    		  		 }
    		  		 else if(n==2)
    		  		 {
    		  			 if(arr[0]==arr[1])
    		  			 {
    		  				 pw.println(-1);
    		  			 }
    		  			 else
    		  			 {
    		  				 pw.println(1+" "+1);
    		  			 }
    		  			 
    		  		 }
    		  		 else
    		  		 {
    		  			 
    		  			 int sum=0;
    		  			 Point[] ap = new Point[n];
    		  			for(int i=0;i<n;i++)
    		  			{
    		  				
    		  				ap[i]= new Point(arr[i],i);
    		  				
    		  			}
    		  			Arrays.sort(ap, new Comp());
    		  			
    		  			pw.println(1+" "+(ap[0].y+1));
    		  			 
    		  			 
    		  		 }
    		  		 
    		  		 
    		  		 
    		  		 /*PriorityQueue<PQnode> pq = new PriorityQueue<PQnode>();
    		  		
    		  		 pw.println(pq.size());
    		  		 
    		  		 pq.add(new PQnode(1,2));
    		  		 pq.add(new PQnode(3,4));
    		  		 
    		  		 pw.println(pq.size());
    		  		pq.remove(new PQnode(1,2));
    		  		 pw.println(pq.size());
    		  		 
    		  		 
    		  		 
    		  		 int parent[] = new int[4];
    		  		 Arrays.fill(parent, -1);
    		  		 ArrayList<Point> adj[] = new ArrayList[4];
    		  		 
    		  		 for(int i=0;i<4;i++)adj[i] = new ArrayList<Point>();
    		  		 
    		  		 adj[0].add(new Point(1,10));
    		  		 adj[0].add(new Point(2,20));
    		  		 
    		  		 adj[1].add(new Point(0,10));
    		  		adj[1].add(new Point(2,5));
    		  		adj[1].add(new Point(3,16));
    		  		
    		  		adj[2].add(new Point(0,20));
    		  		adj[2].add(new Point(1,5));
    		  		adj[2].add(new Point(3,20));
    		  		
    		  		adj[3].add(new Point(1,16));
    		  		adj[3].add(new Point(2,20));
    		  		 
    		  		 
    		  		 
    		  		 PriorityQueue<PQnode> pq = new PriorityQueue<PQnode>(new Compq());
    		  		 HashSet<Integer> pres = new HashSet<Integer>();
    		  		 
    		  		 int[] dist = new int[4];
    		  		 
    		  		 for(int i=0;i<4;i++)
    		  		 {
    		  			 if(i==0)
    		  			 {
    		  				pq.add(new PQnode(i,0)); 
    		  				dist[i]=0;
    		  			 }
    		  			 else
    		  			 {
    		  				 pq.add(new PQnode(i,Integer.MAX_VALUE));
    		  				 dist[i]=Integer.MAX_VALUE;
    		  			 }
    		  			 pres.add(i);
    		  			 
    		  		 }
    		  		 
    		  		 
    		  		 while(!pq.isEmpty())
    		  		 {
    		  			 PQnode pop = pq.poll();
    		  			 pres.remove(pop.value);
    		  			// pw.println(pop.value+" "+pop.distance);
    		  			 dist[pop.value]=pop.distance;
    		  			 for(Point p: adj[pop.value])
    		  			 {
    		  				 if(pres.contains(p.x))
    		  				 {
    		  					 if(p.y+dist[pop.value]<dist[p.x])
    		  					 {
    		  						 pw.println("ha");
    		  						
    		  						 pq.remove(new PQnode(p.x,dist[p.x]));
    		  						 dist[p.x]=p.y+dist[pop.value];
    		  						 pq.add(new PQnode(p.x,p.y+dist[pop.value]));
    		  						 parent[p.x]=pop.value;
    		  					 }
    		  				 }
    		  			 }
    		  			 
    		  		 }
    		  		 
    		  		 
    		  		 
    		  		 
    		  		 for(int i=0;i<4;i++)pw.print(dist[i]+" ");
    		  		pw.println();
    		  		 printpa(parent, 3	);
    		  		 
    		  		 
    		  		 
    		  		 
    		  		 Dijkstra over.
    		  		 */
    		  		 
    		  		 
    		  		 
    		  		 
    		  		 
    		  		 
    		  		 /*
    		  		st = new Stack<Integer>();
    		  		 
    			 
    			  cyc=0;
       			adj = new ArrayList[4];
       			vis2 = new int[4];
       			
       			Arrays.fill(vis2, 0);
       			for(int i=0;i<4;i++)adj[i] = new ArrayList<Integer>();
       			   
       			
       			adj[0].add(1);
       			adj[0].add(2);
       			adj[0].add(3);
       			
       			adj[1].add(3);
       			
       			//adj[2].add(0);
       			adj[2].add(1);
    			   //adj[3].add(2);
    			   
       			st = new Stack<Integer>();
    			
       			topo(0);
    			   
    			 while(!st.isEmpty())pw.println(st.pop());
    			 */
    				 
    			/*
    			int n = sc.nextInt();
    			
    			int arr[] = new int[n];
    			
    			for(int i=0;i<n;i++)arr[i]=sc.nextInt();
    			
    			long ansg =0,ansv = Long.MAX_VALUE; 
    			
    			int arr2[] = new int[n];
    			for(int i=0;i<n;i++)arr2[i]=arr[i]-i;
    		
    			for(int i=0;i<n;i++)
    			{
    				int x = arr2[i];
    				
    				if(x<=0)
    				{
    					
    					if(i<ansv)
    					{
    						
    						ansg=i;
    						ansv=i;
    					}
    				}
    				else
    				{
    					float t = ((float)x)/n;
    					long tt = (long)Math.ceil(t);
    					
    					long ex = i;
    					long ti = tt*n+ex;
    					
    					
    					if(ti<ansv)
    					{
    						//pw.println("** "+i);
    						ansg=i;
    						ansv=ti;
    					}
    					
    				}
    				
    				
    				
    			}
    			
    			pw.println(ansg+1);
    			*/
    			   
    			   
    			   
    		
    			   
    			   
    	
    			   
    			   /*ct=0;
    			
    			paths= new ArrayList[10];
    			adj = new ArrayList[4];
    			vis2 = new int[4];
    			
    			for(int i=0;i<4;i++)adj[i] = new ArrayList<Integer>();
    			   
    			for(int i=0;i<10;i++)paths[i] = new ArrayList<Integer>();
    			
    			adj[0].add(1);
    			adj[0].add(2);
    			adj[0].add(3);
    			
    			adj[1].add(3);
    			
    			adj[2].add(0);
    			adj[2].add(1);
    			
    			countPaths(2,3, new ArrayList<Integer>());
    			pw.println(ct);
    			   
    			for(int i=0;i<ct;i++)pw.println(paths[i]);
    			  */ 
    			   
    			   
    			   
    			   /*
    			   int n = sc.nextInt();
    			int m = sc.nextInt();
    			
    			int arr[] = new int[n];
    			
    			for(int i=0;i<n;i++)arr[i]=sc.nextInt();
    			
    			int req = n/m;
    			
    			int[] rem = new int[m];
    			
    			
    			HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
    			for(int i=0;i<n;i++)
    			{
    				rem[arr[i]%m]++;
    				
    			}
    			int li=-1;
    			long ans=0;
    			for(int i=0;i<m;i++)
    			{
    				if(rem[i]>=req)
    				{
    					rem[(i+1)%m]+=rem[i]-req;
    					ans+=(rem[i]-req);
    				}
    				else
    				{
    					li=i;
    					
    				}
    			}
    			
    			for(int i=0;i<li;i++)
    			{
    				if(rem[i]>=req)
    				{
    					rem[(i+1)%m]+=rem[i]-req;
    					ans+=(rem[i]-req);
    				}
    				else
    				{
    					li=i;
    					
    				}
    			}
    			pw.println(ans);
    			*/
    			
    			
    			
    			   //pw.println(pa);
    		/*	  NGE 
       		int[] sto = {100,80,60,70,60,75,85};
       		int n = sto.length;
       		
       		int[] spa = new int[n];
       		spa[0]=1;
       		
       		Stack<Integer> st = new Stack<Integer>();
       		st.push(0);
       		
       		for(int i=1;i<n;i++)
       		{
       			
       			while(!st.isEmpty()&&sto[st.peek()]<=sto[i])st.pop();
       			
       			spa[i]=(st.isEmpty())?i+1:i-st.peek();
       			st.push(i);
       			
       		}
    			  
       		
       		for(int i=0;i<n;i++)pw.print(sto[i]+" ");
    			   pw.println();
    			   for(int i=0;i<n;i++)pw.print(spa[i]+" ");
    			  
    			   
    			   int[] nge = new int[n];
    			   
    			   st.clear();
    			   Stack<Point> st2 = new Stack<Point>();
    			   st2.push(new Point(sto[0],0));
    			   
    			   for(int i=1;i<n;i++)
    			   {
    				   while(!st2.isEmpty()&&st2.peek().x<sto[i])
    				   {
    					   Point pop = st2.pop();
    					   nge[pop.y]=sto[i];
    				   }
    				   st2.push(new Point(sto[i],i));
    				   
    			   }
    			   
    			   while(!st2.isEmpty())
    			   {
    				   nge[st2.pop().y]=-1;
    			   }
    			  
    			   pw.println();
    			   for(int i=0;i<n;i++)pw.print(sto[i]+" ");
    			   pw.println();
    			   for(int i=0;i<n;i++)pw.print(nge[i]+" ");
    			 */ 
    			   
    			   /*  int r = 2000000000;
    			  pw.println(r);
    			int n = sc.nextInt();
    			int k = sc.nextInt();
    			int l = sc.nextInt();
    			int m = n*k;
    			int arr[] = new int[m];
    			
    			for(int i=0;i<m;i++)arr[i]=sc.nextInt();
    			
    			Arrays.sort(arr);
    			
    			int limit = l+arr[0];
    			int li=-1;
    			
    			for(int i=0;i<m;i++)
    			{
    				//pw.println(arr[i]);
    				if(arr[i]>limit)
    				{
    					//pw.println(arr[i]);
    					li=i; break;
    				}
    			}
    			//pw.println(limit+" "+li);
    			if(li==-1)li=n;
    			
    			int noofsmallest = li;
    			
    			if(noofsmallest<n)
    			{
    				pw.println(0);
    			}
    			else
    			{
    				li--;
    				long ans=0;
    				for(int i=0;i<n-1;i++)
    				{
    					ans+=(long)arr[li];
    					li--;
    				}
    				ans+=arr[0];
    				pw.println(ans);
    				
    			}
    			  */ 
    			   
    			   
    			   
    		
    			 
    			  
    			pw.close();  
    			   
    	   }
    		   
    		   
    		   
    		   static  class MyScanner 
    			{
    	
    			BufferedReader br;
    			StringTokenizer st;
    	
    			public MyScanner() 
    			{
    				br = new BufferedReader(new InputStreamReader(System.in));
    			}
    	
    			String next() 
    			{
    				
    				while (st == null || !st.hasMoreElements()) 
    				{
    					try 
    					{
    						st = new StringTokenizer(br.readLine());
    					} catch (IOException e) 
    					{
    						e.printStackTrace();
    					}
    				}
    				return st.nextToken();
    			}
    	
    			int nextInt() 
    			{
    				return Integer.parseInt(next());
    			}
    	
    			long nextLong() 
    			{
    				return Long.parseLong(next());
    			}
    	
    			double nextDouble() 
    			{
    				return Double.parseDouble(next());
    			}
    	
    			String nextLine()
    			{
    				String str = "";
    				try 
    				{
    					str = br.readLine();
    				} catch (IOException e) 
    				{
    					e.printStackTrace();
    				}
    				return str;
    			}
    	
    		}
    	
    		static MyScanner sc = new  MyScanner();
    		static PrintWriter pw = new PrintWriter(System.out, true);
    		
    		static class DisjointSet
    		{
    			int[] parent;
    			int[] rank;
    			int n;
    			
    			public DisjointSet(int x)
    			{
    				n=x;
    				parent = new int[x];
    				rank = new int[x];
    				
    				for(int i=0;i<n;i++)
    				{
    					parent[i]=i;
    				}
    				
    			}
    			
    			public int find(int x)
    			{
    				
    				if(parent[x]==x)
    					return x;
    				else 
    					return find(parent[x]);
    			}
    			
    			public void union(int i, int j)
    			{
    				int iroot = find(i);
    				int jroot = find(j);
    				
    				if(iroot==jroot)
    					return;
    				
    				if(rank[iroot]<rank[jroot])
    				{
    					parent[iroot]=jroot;
    					
    				}
    				else if(rank[jroot]<rank[iroot])
    				{
    					parent[jroot]=iroot;
    				}
    				else
    				{
    					parent[iroot]=jroot;
    					rank[jroot]++;
    					
    				}
    				
    				
    				
    				
    			}
    			
    			
    			
    			
    			
    		}
    	
    		
    	}  