You are given an array a consisting of n non-negative integers. You have to choose a non-negative integer x and form a new array b of size n according to the following rule: for all i from 1 to n, b_i = a_i ⊕ x (⊕ denotes the operation [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR)).

An inversion in the b array is a pair of integers i and j such that 1 ≤ i < j ≤ n and b_i > b_j.

You should choose x in such a way that the number of inversions in b is minimized. If there are several options for x — output the smallest one.

Input

First line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements in a.

Second line contains n space-separated integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.

Output

Output two integers: the minimum possible number of inversions in b, and the minimum possible value of x, which achieves those number of inversions.

Examples

Input


4
0 1 3 2


Output


1 0


Input


9
10 7 9 10 7 5 5 3 5


Output


4 14


Input


3
8 10 3


Output


0 8

Note

In the first sample it is optimal to leave the array as it is by choosing x = 0.

In the second sample the selection of x = 14 results in b: [4, 9, 7, 4, 9, 11, 11, 13, 11]. It has 4 inversions:

  * i = 2, j = 3; 
  * i = 2, j = 4; 
  * i = 3, j = 4; 
  * i = 8, j = 9. 



In the third sample the selection of x = 8 results in b: [0, 2, 11]. It has no inversions.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class Main
{
	static long sum[][] ;

	public static void main(String[] args) {
		new Thread(null, new Runnable() {
			public void run() {
                solve();
            }
        }, "1", 1 << 26).start();
	}
	static void solve () {
		FastReader fr =new FastReader();	PrintWriter op =new PrintWriter(System.out);
 
 		int N =fr.nextInt() ,i ,j =-1 ,k ,xor ;	long ans ;

 		ArrayList<Integer> num =new ArrayList<>() ;

 		while (N-->0) {
 			i =fr.nextInt() ;

 			j =Math.max(j,i) ;

 			num.add(i) ;
 		}

 		if (j==0)
 			op.println("0 0") ;
 		else {
 			i =1 ;	k =0 ;

 			while (i*2 <= j) {
 				i *= 2 ;	++k ;
 			}

 			sum =new long[k+1][2] ; 

 			ans =xor =0 ;

 			rec(num , i , k) ;

 			for (j =k ; j>=0 ; --j ,i /= 2) {//System.out.println(sum[j][0]+" "+sum[j][1]) ;
 				if (sum[j][0] <= sum[j][1])
 					ans += sum[j][0] ;
 				else {
 					ans += sum[j][1] ;

 					xor += i ;
 				}
 			}

 			op.println(ans+" "+xor) ;
		}

		op.flush();	op.close();
	}
	static void rec (ArrayList<Integer> num , int msb , int bit) {//System.out.println(num+"__"+msb+" "+bit) ;
		int N =num.size() ,zero[][] =new int[N+2][2] ,i ;

		long j =0l ,k =0l ;

		if (bit==-1)	return;

		ArrayList<Integer> Z =new ArrayList<>() ,O =new ArrayList<>() ;

		for (i =0 ; i<N ; ++i) {
			if ((num.get(i)&msb) == 0) {
				zero[i+1][0] =zero[i+1][1] =1 ;

				Z.add(num.get(i)) ;
			}
			else
				O.add(num.get(i)) ;
		}

		for (i =1 ; i<=N ; ++i)	zero[i][0] += zero[i-1][0] ;

		for (i =N ; i>0 ; --i)	zero[i][1] += zero[i+1][1] ;

		for (i =1 ; i<=N ; ++i) {
			if (zero[i][0]-zero[i-1][0] == 0) {
				j += zero[i+1][1] ;

				k += zero[i-1][0] ;
			}
		}

		sum[bit][0] += j ;	sum[bit][1] += k ;

		msb /= 2 ;	--bit ;

		if (!Z.isEmpty())
			rec(Z , msb , bit) ;
		if (!O.isEmpty())
			rec(O , msb , bit) ;
	}
	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();
		}

		String nextLine() {
			String str ="";

			try
			{
				str =br.readLine();
			}
			catch(IOException e)
			{
				e.printStackTrace();
			}

			return str;
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next()) ;
		}
	}
}