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.

// ~/BAU/ACM-ICPC/Teams/A++/BlackBurn95
// ~/sudo apt-get Accpeted

import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;
import static java.lang.String.*;

public class Main {

    static int n,k,x;
    static int [] a;
    static long [][] dp;
    
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder out = new StringBuilder();
        StringTokenizer tk;
        
        tk = new StringTokenizer(in.readLine());
        n = parseInt(tk.nextToken());
        k = parseInt(tk.nextToken());
        x = parseInt(tk.nextToken());
        
        a = new int[n];
        long mx = 0,p = pow1(x,k);
        long [] pre = new long[n];
        long [] suf = new long[n];
        
       // dp = new long[n][k+1];
        tk = new StringTokenizer(in.readLine());
        for(int i=0; i<n; i++) {
            a[i] = parseInt(tk.nextToken());
          //  Arrays.fill(dp[i], -1);
            pre[i] = a[i]; 
            if(i>0) pre[i] |= pre[i-1];
        }
        for(int i=n-1; i>=0; i--) {
            suf[i] = a[i];
            if(i<n-1) suf[i] |= suf[i+1];
        }
        
        for(int i=0; i<n; i++) 
            mx = max(mx, (i==0 ? 0 : pre[i-1]) | p*(long)a[i] | (i==n-1 ? 0 : suf[i+1]));
        
        System.out.println(mx);
    }
    
    static long calc(int i,int r) {
        if(i==n)
            return 0;
        
        if(dp[i][r]!=-1)
            return dp[i][r];
        
        if(r==0) return dp[i][r] = calc(i+1,0) | (long)a[i];
        
        long res = calc(i+1,r) | a[i];
        for(int j=1; j<=r; j++)
            res = max(res, calc(i+1,r-j) | pow1(x,j)*(long)a[i]);
        
        return dp[i][r] = res;
    }
    
    static long pow1(int n,int p) {
        return (long)pow(n,p);
    }
}
