You are given a sequence a_1, a_2, ..., a_n consisting of n integers.

You can choose any non-negative integer D (i.e. D ≥ 0), and for each a_i you can:

  * add D (only once), i. e. perform a_i := a_i + D, or 
  * subtract D (only once), i. e. perform a_i := a_i - D, or 
  * leave the value of a_i unchanged. 



It is possible that after an operation the value a_i becomes negative.

Your goal is to choose such minimum non-negative integer D and perform changes in such a way, that all a_i are equal (i.e. a_1=a_2=...=a_n).

Print the required D or, if it is impossible to choose such value D, print -1.

For example, for array [2, 8] the value D=3 is minimum possible because you can obtain the array [5, 5] if you will add D to 2 and subtract D from 8. And for array [1, 4, 7, 7] the value D=3 is also minimum possible. You can add it to 1 and subtract it from 7 and obtain the array [4, 4, 4, 4].

Input

The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of elements in a.

The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100) — the sequence a.

Output

Print one integer — the minimum non-negative integer value D such that if you add this value to some a_i, subtract this value from some a_i and leave some a_i without changes, all obtained values become equal.

If it is impossible to choose such value D, print -1.

Examples

Input


6
1 4 4 7 4 1


Output


3


Input


5
2 2 5 2 5


Output


3


Input


4
1 3 3 7


Output


-1


Input


2
2 8


Output


3
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;


 public class hello2
 {static class FastReader 
       { 
           BufferedReader br; 
           StringTokenizer st; 
     
           public FastReader() 
           { 
               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 String sum (String s)
    {
        String s1 = ""; 
        
        if(s.contains("a"))
            s1+="a";
        if(s.contains("e"))
            s1+="e";
        if(s.contains("i"))
            s1+="i";
        if(s.contains("o"))
            s1+="o";
        if(s.contains("u"))
            s1+="u";
        
            return s1;
            
        
    }
    

    public static HashMap<String, Integer> sortByValue(HashMap<String, Integer> hm) 
    { 
        // Create a list from elements of HashMap 
        List<Map.Entry<String, Integer> > list = 
               new LinkedList<Map.Entry<String, Integer> >(hm.entrySet()); 
  
        // Sort the list 
        Collections.sort(list, new Comparator<Map.Entry<String, Integer> >() { 
            public int compare(Map.Entry<String, Integer> o1,  
                               Map.Entry<String, Integer> o2) 
            { 
                return (o1.getValue()).compareTo(o2.getValue()); 
            } 
        }); 
          
        // put data from sorted list to hashmap  
        HashMap<String, Integer> temp = new LinkedHashMap<String, Integer>(); 
        for (Map.Entry<String, Integer> aa : list) { 
            temp.put(aa.getKey(), aa.getValue()); 
        } 
        return temp; 
    } 
    static int gcd(int x,int y)
    {
    	if(x==0 )
    		return y;
    	if(y==0)
    		return x;
    	
    	if(x==y)
    	{
    		return x;
    	}
    	if(x>y)
    	{
    		return gcd(x-y,y);
    	}
    	else
    		return gcd(x,y-x);
    	
    }
   
    
    public static void main(String args[])
    {
        FastReader input =new FastReader();
        
        int t = input.nextInt();
        
        int a[] = new int[t];
        for(int i=0;i<t;i++)
        {
        	a[i] = input.nextInt();
        }
        Arrays.sort(a);
        int count =0;
        int min =1000,max =0;
        for(int i=0;i<t;i++)
        {
        	
        	if(a[i]>max)
        	{
        		max = a[i];
        	}
        	if(a[i]<min)
        	{
        		min = a[i];
        	}
        		
        }
        
        for(int i=0;i<t-1;i++)
        {
        	if(a[i]!=a[i+1])
        	{
        		count++;
        	}
        }
        
       
        int mid =0;
        if(count!=2 && count!=1 && count!=0)
        {
        	System.out.println(-1);
        }
        else
        {
        	if(count==0)
        	{
        		System.out.println(0);
        	}
        	if(count==1)
        	{
        		if((max - min) %2==0)
        		{
        			int z = (max+min)/2;
        			
        			System.out.println((z-min));
        		}
        		else
        		{
        			System.out.println((max-min));
        		}
        	}
        	else if(count==2)
        	{
        		for(int i=0;i<t;i++)
        		{
        			if(a[i]!=max && a[i]!=min)
        			{
        				mid = a[i];
        			}
        		}
        		
        		if(max - mid != mid - min)
        			System.out.println(-1);
        		else
        			System.out.println(mid -min);
        	}
        	else;
        	
        
        }
        
    }
    
    
    static void decToBinary(long n) 
    { 
        // array to store binary number 
        int[] binaryNum = new int[100]; 
   
        // counter for binary array 
        int i = 0; 
        while (n > 0)  
        { 
            // storing remainder in binary array 
            binaryNum[i] = (int)n % 2; 
            n = n / 2; 
            i++; 
        } 
        long count =0;
        // printing binary array in reverse order 
        for (int j = i - 1; j >= 0; j--) 
        {
        	if(binaryNum[j]==1)
        	{
        		count++;
        	}
        	
        }
        
            System.out.print(count); 
    } 
    static boolean isPrime(int n) 
    { 
        // Corner case 
        if (n <= 1) 
            return false; 
  
        // Check from 2 to n-1 
        for (int i = 2; i < n; i++) 
            if (n % i == 0) 
                return false; 
  
        return true; 
    } 
}
