You are given n numbers a1, a2, ..., an. You can perform at most k operations. For each operation you can multiply one of the numbers by x. We want to make <image> as large as possible, where <image> denotes the bitwise OR. 

Find the maximum possible value of <image> after performing at most k operations optimally.

Input

The first line contains three integers n, k and x (1 ≤ n ≤ 200 000, 1 ≤ k ≤ 10, 2 ≤ x ≤ 8).

The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109).

Output

Output the maximum value of a bitwise OR of sequence elements after performing operations.

Examples

Input

3 1 2
1 1 1


Output

3


Input

4 2 3
1 2 4 8


Output

79

Note

For the first sample, any possible choice of doing one operation will result the same three numbers 1, 1, 2 so the result is <image>. 

For the second sample if we multiply 8 by 3 two times we'll get 72. In this case the numbers will become 1, 2, 4, 72 so the OR value will be 79 and is the largest possible result.

import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.*;

import static java.lang.Long.bitCount;

/**
 * @author Tran Anh Tai
 * @template for CP codes
 *
 */
public class ProbA {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(in, out);
        out.close();
    }
    // main solver
    static class Task{
        public void solve(InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int k = in.nextInt();
            int x = in.nextInt();
            int[] a = new int[n];
            int[][] bits = new int[n][64];
            int totalBits[] = new int[64];
            long or = 0;
            for(int i = 0; i < n; i++){
                a[i] = in.nextInt();
                bits[i] = getBits(a[i]);
                for (int j = 0; j < 64; j++){
                    totalBits[j] += bits[i][j];
                }
                or = or | a[i];
            }
            int[] orBits = getBits(or);
            long au = 1;
            for (int i = 0; i < k; i++){
                au = au * x;
            }
            long result = 0;
            for (int i =0; i < n; i++){
                long y = 0;
                for (int j = 0; j < 64; j++){
                    if (orBits[j] == 0){
                        y = y << 1;
                    }
                    else{
                        if (totalBits[j] > 1 || bits[i][j] == 0){
                            y = (y << 1) + 1;
                        }
                        else{
                            y = y << 1;
                        }
                    }
                }
                result = Math.max(result, y | (a[i] * au));
            }
            out.print(result);
        }

        private int[] getBits(long n) {
            int[] bits = new int[64];
            for (int i = 63; i>= 0;i--){
                bits[i] = (int)(n % 2);
                n = n >> 1;
            }
            return bits;
        }
    }
    // fast input reader class;
    static class InputReader {
        BufferedReader br;
        StringTokenizer st;

        public InputReader(InputStream stream) {
            br = new BufferedReader(new InputStreamReader(stream));
        }

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

        public int nextInt() {
            return Integer.parseInt(nextToken());
        }
        public long nextLong(){
            return Long.parseLong(nextToken());
        }
    }
}