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

public class E673 {
    static long res;
    static int [] zero;
    static int [] one;
    static int n;
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
        n = sc.nextInt();
        ArrayList<Long> a = new ArrayList<>();
        for (int i = 0; i < n; i++) a.add(sc.nextLong());
        res = 0;
        zero = new int[32];
        one = new int[32];
        dfs(31, a);
        //long inv = 0;
        for (int i = 0; i < 32; i++) {
            if (zero[i] > one[i]) res += (1L << i);
            //inv += Math.min(zero[i], one[i]);
        }
        int [] arr = new int[n + 1];
        for (int i = 1; i <= n; i++) arr[i] = (int) (a.get(i - 1) ^ res);
        Pair [] p = new Pair[n]; long inv = 0;
        for (int i = 1; i <= n; i++) p[i - 1] = new Pair(i, arr[i]);
        Arrays.sort(p);
        FenwickTree bit = new FenwickTree(n + 1);
        for (int i = 0; i < n; i++) {
            inv += bit.sum(p[i].i);
            bit.update(p[i].i, 1);
        }
        out.println(inv + " " + res);
        out.close();
    }

    static class Pair implements Comparable<Pair> {
        int i; int val;
        Pair(int i, int val) {
            this.i = i; this.val = val;
        }

        @Override
        public int compareTo(Pair o) {
            if (val == o.val) return Integer.compare(o.i, i);
            return Integer.compare(o.val, val);
        }
    }

    static void dfs(int b, ArrayList<Long> a) {
        if (a.size() == 0) return;
        if (b < 0) return;
        int z = 0; int o = 0; long keep = 0; long change = 0;
        ArrayList<Long> zz = new ArrayList<>();
        ArrayList<Long> oo = new ArrayList<>();
        for (int i = 0; i < a.size(); i++) {
            long here = ((a.get(i) >> b) & 1);
            if (here == 0) {
                keep += o;
                z++;
                zz.add(a.get(i));
            } else {
                change += z;
                o++;
                oo.add(a.get(i));
            }
        }
        zero[b] += keep;
        one[b] += change;
        dfs(b - 1, zz);
        dfs(b - 1, oo);
    }


    static class FenwickTree
    {
        int size;
        int [] table;

        FenwickTree(int size)
        {
            table = new int [size];
            this.size = size;
        }

        void init(int [] nums)
        {
            for (int i = 1; i < nums.length; i++)
            {
                update(i, nums[i]);
            }
        }

        void update(int i, int delta)
        {
            while (i < size)
            {
                table[i] += delta;
                i += Integer.lowestOneBit(i);
            }
        }

        int sum(int i)
        {
            int sum = 0;
            while (i > 0)
            {
                sum += table[i];
                i -= Integer.lowestOneBit(i);
            }
            return sum;
        }

        int rangeSum(int i, int j)
        {
            return sum(j) - sum(i - 1);
        }
    }



    //-----------MyScanner class for faster input----------
    public 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;
        }


    }

}