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.
/*
     * Code Author: Akshay Miterani
     * DA-IICT
     */
    import java.io.*;
import java.util.*;
     
    public class Contest {
     
    	static final int mod=(int)1e9+7;
    	static int n=0;
    	//static long a[]=new long[n];
    	//static boolean vis[]=new boolean[n];
    	//static ArrayList<Integer> a=new ArrayList<Integer>();
    	//static Pair p[]=new Pair[n];
    	public static void main(String args[]){
    		InputReader in = new InputReader(System.in);
    		OutputStream outputStream = System.out;
    		PrintWriter out = new PrintWriter(outputStream);
    		//----------My Code Starts Here----------
    		int n=in.nextInt();
    		int k=in.nextInt();
    		int x=in.nextInt();
    		int a[]=new int[n];
    		for(int i=0;i<n;i++)
    			a[i]=in.nextInt();
    		int pre[]=new int[n+1];
    		pre[0]=0;
    		for(int i=1;i<=n;i++){
    			pre[i]=pre[i-1]|a[i-1];
    		}
    		int suf[]=new int[n+1];
    		suf[n]=0;
    		for(int i=n-1;i>=0;i--){
    			suf[i]=suf[i+1]|a[i];
    		}
    		long ans=Integer.MIN_VALUE;
    		for(int i=0;i<n;i++){
    			ans=Math.max(ans, pre[i]|suf[i+1]|(a[i]*(long)Math.pow(x, k)));
    		}
    		System.out.println(ans);
    		out.close();		
    		//---------------The End------------------
    	}
    	static class Pair implements Comparable<Pair>{
    		int L,R,i;
    		Pair(){}
    		Pair(int ii,int cc){
    			L=ii;R=cc;
    		}
			@Override
			public int compareTo(Pair o) {
				return -Integer.compare(R,o.R);
			}
			
    	}
    	
    	static class InputReader {
    	    public BufferedReader reader;
    	    public StringTokenizer tokenizer;
     
    	    public InputReader(InputStream inputstream) {
    	      reader = new BufferedReader(new InputStreamReader(inputstream));
    	      tokenizer = null;
    	    }
    	    
    	    public String nextLine(){
    	    	String fullLine=null;
    	    	while (tokenizer == null || !tokenizer.hasMoreTokens()) {
    	            try {
    	              fullLine=reader.readLine();
    	            } catch (IOException e) {
    	              throw new RuntimeException(e);
    	            }
    	            return fullLine;
    	          }
    	          return fullLine;
    	    }
    		public String next() {
    	      while (tokenizer == null || !tokenizer.hasMoreTokens()) {
    	        try {
    	          tokenizer = new StringTokenizer(reader.readLine());
    	        } catch (IOException e) {
    	          throw new RuntimeException(e);
    	        }
    	      }
    	      return tokenizer.nextToken();
    	    }
    		public long nextLong() {
    		      return Long.parseLong(next());
    		    }
    	    public int nextInt() {
    	      return Integer.parseInt(next());
    	    }
    	  }
    } 