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

public class T5 extends PrintWriter {
    public T5() {
        super(System.out);
    }

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        T5 main = new T5();
        int n = 1;
        while (n-- > 0) {
            main.MainPrint(s);
        }
        main.flush();
    }
    private void MainPrint(Scanner s) {
        int n = s.nextInt();
        int[] nums = new int[n];
        for (int i=0;i<n;i++){
            nums[i] = s.nextInt();
        }
        int[] copy = new int[n];
        System.arraycopy(nums,0,copy,0,n);
        long inverse = q(copy);
        long min = inverse;
        int x = 0;
        long dis;

        for (int i = 0; i < 31;i++){
            if ((dis = inverse - q(nums,i))> 0) {
                x |= 1 << i;
                min -= dis;
            }
        }

        println(min + " " + x);
    }

    private long q(int[] nums, int i) {
        int[] nums1 = new int[nums.length];
        for (int j = 0; j < nums.length; j++){
            nums1[j] = nums[j]^(1<<i);
        }
        return q(nums1);
    }

    private long q(int[] nums){
//        println(Arrays.toString(nums));
        rem = new int[nums.length];
        long ans = q(nums,0,nums.length - 1);
//        println(ans);
        return ans;
    }
    int[] rem;
    private long q(int[] nums,int start,int end){
        if (start == end) return 0;
        int mid = (start+end)/2;
        long ans = q(nums, start, mid) + q(nums, mid + 1, end);
        int p = start, q = mid + 1, r = start;

        while(p<=mid && q<=end){
            if (nums[p]<=nums[q]) rem[r++] = nums[p++];
            else {
                rem[r++] = nums[q++];
                ans += mid - p + 1;
            }
        }

        while (p<=mid){
            rem[r++] = nums[p++];
        }
        while (q<=end){
            rem[r++] = nums[q++];
        }
        System.arraycopy(rem,start,nums,start,end - start + 1);
        return ans;
    }
}