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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Collection;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Queue;
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.LinkedList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        CXORInverse solver = new CXORInverse();
        solver.solve(1, in, out);
        out.close();
    }

    static class CXORInverse {
        long[] level;
        long[] levelInv;

        public void solve(int testNumber, Scanner sc, PrintWriter pw) {
            int n = sc.nextInt();
            Queue<Integer> q = new LinkedList<>();
            for (int i = 0; i < n; i++)
                q.add(sc.nextInt());
            levelInv = new long[30];
            level = new long[30];
            get(q, 29);
            long x = 0, xor = 0;
            for (int bit = 29; bit >= 0; bit--) {
                if (levelInv[bit] < level[bit]) {
                    x += levelInv[bit];
                    xor += 1 << bit;
                } else
                    x += level[bit];
            }
            pw.println(x + " " + xor);
        }

        private void get(Queue<Integer> q, int bit) {
            if (q.isEmpty() || bit == -1)
                return;
            long inversionsOne = 0, inversionsZero = 0;
            int prevOne = 0, prevZero = 0;
            Queue<Integer> ones = new LinkedList<>(), zeros = new LinkedList<>();
            while (!q.isEmpty()) {
                int x = q.poll();
                if ((x & 1 << bit) == 0) {
                    zeros.add(x);
                    prevZero++;
                    inversionsZero += prevOne;
                } else {
                    ones.add(x);
                    prevOne++;
                    inversionsOne += prevZero;
                }
            }
            level[bit] += inversionsZero;
            levelInv[bit] += inversionsOne;
            get(zeros, bit - 1);
            get(ones, bit - 1);

        }

    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

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

    }
}

