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.BufferedReader;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.PrintWriter;
	import java.util.ArrayList;
	import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
	import java.util.HashSet;
	import java.util.InputMismatchException;
	import java.util.Iterator;
	import java.util.TreeSet;
									public class Solution1 implements Runnable
									{
										static final long MAX = 1000000007L;
										static class InputReader
										{
											private InputStream stream;
											private byte[] buf = new byte[1024];
											private int curChar;
											private int numChars;
											private SpaceCharFilter filter;
											private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
									 
											public InputReader(InputStream stream)
											{
												this.stream = stream;
											}
											
											public int read()
											{
												if (numChars==-1) 
													throw new InputMismatchException();
												
												if (curChar >= numChars)
												{
													curChar = 0;
													try 
													{
														numChars = stream.read(buf);
													}
													catch (IOException e)
													{
														throw new InputMismatchException();
													}
													
													if(numChars <= 0)				
														return -1;
												}
												return buf[curChar++];
											}
										 
											public String nextLine()
											{
												String str = "";
									            try
									            {
									                str = br.readLine();
									            }
									            catch (IOException e)
									            {
									                e.printStackTrace();
									            }
									            return str;
											}
											public int nextInt()
											{
												int c = read();
												
												while(isSpaceChar(c)) 
													c = read();
												
												int sgn = 1;
												
												if (c == '-') 
												{
													sgn = -1;
													c = read();
												}
												
												int res = 0;
												do 
												{
													if(c<'0'||c>'9') 
														throw new InputMismatchException();
													res *= 10;
													res += c - '0';
													c = read();
												}
												while (!isSpaceChar(c)); 
												
												return res * sgn;
											}
											
											public long nextLong() 
											{
												int c = read();
												while (isSpaceChar(c))
													c = read();
												int sgn = 1;
												if (c == '-') 
												{
													sgn = -1;
													c = read();
												}
												long res = 0;
												
												do 
												{
													if (c < '0' || c > '9')
														throw new InputMismatchException();
													res *= 10;
													res += c - '0';
													c = read();
												}
												while (!isSpaceChar(c));
													return res * sgn;
											}
											
											public double nextDouble() 
											{
												int c = read();
												while (isSpaceChar(c))
													c = read();
												int sgn = 1;
												if (c == '-') 
												{
													sgn = -1;
													c = read();
												}
												double res = 0;
												while (!isSpaceChar(c) && c != '.') 
												{
													if (c == 'e' || c == 'E')
														return res * Math.pow(10, nextInt());
													if (c < '0' || c > '9')
														throw new InputMismatchException();
													res *= 10;
													res += c - '0';
													c = read();
												}
												if (c == '.') 
												{
													c = read();
													double m = 1;
													while (!isSpaceChar(c)) 
													{
														if (c == 'e' || c == 'E')
															return res * Math.pow(10, nextInt());
														if (c < '0' || c > '9')
															throw new InputMismatchException();
														m /= 10;
														res += (c - '0') * m;
														c = read();
													}
												}
												return res * sgn;
											}
											
											public String readString() 
											{
												int c = read();
												while (isSpaceChar(c))
													c = read();
												StringBuilder res = new StringBuilder();
												do 
												{
													res.appendCodePoint(c);
													c = read();
												} 
												while (!isSpaceChar(c));
												
												return res.toString();
											}
										 
											public boolean isSpaceChar(int c) 
											{
												if (filter != null)
													return filter.isSpaceChar(c);
												return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
											}
										 
											public String next() 
											{
												return readString();
											}
											
											public interface SpaceCharFilter 
											{
												public boolean isSpaceChar(int ch);
											}
										}
									 	
										public static void main(String args[]) throws Exception
										{
											new Thread(null, new Solution1(),"Solution1",1<<26).start();
										}
										
										static long gcd(long a, long b)
									    {
									        // Everything divides 0 
									        if (a == 0 || b == 0)
									           return 0;
									     
									        // base case
									        if (a == b)
									            return a;
									     
									        // a is greater
									        if (a > b)
									            return gcd(a-b, b);
									        return gcd(a, b-a);
									    }
									    
									    // method to return LCM of two numbers
									    static long lcm(long a, long b)
									    {
									        return (a*b)/gcd(a, b);
									    }
									    class Node{
									    	long val;
									    	int ind;
									    	Node(long val,int ind){
									    		this.val = val;
									    		this.ind = ind;
									    	}
									    }
									    
									    TreeSet<Integer> ar[];
										public void run()
										{
											InputReader sc= new InputReader(System.in);
											PrintWriter w= new PrintWriter(System.out);
											int n = sc.nextInt();
											int k = sc.nextInt();
											long x = sc.nextLong();
											long[] arr = new long[n];
											for(int i = 0;i < n;i++) {
												arr[i] = sc.nextLong();
											}
											long[] bit = new long[64];
											long or = 0;
											for(int i = 0;i < n;i++) {
												for(int j = 0;j < 64;j++) {
													if(((arr[i] >> j) & 1) == 1) {
														bit[j]++;
													}
												}
												or = or | arr[i];
											}
											long max = or;
											for(int i = 0;i < n;i++) {
												long temp = arr[i];
												for(int j = 0;j < k;j++) {
													temp = temp * x;
												}
												long tans = or;
												for(int j = 0;j < 64;j++) {
													if(((arr[i] >> j) & 1) == 1 && bit[j] == 1) {
														tans = tans - (1 << j);
													}
												}
												tans = tans | temp;
												max = Math.max(max,tans);
											}
											w.println(max);
											w.close();
											
										}
										class Nod{
											int x;
											int y;
											int z;
											int l;
											Nod(int x,int y,int z,int l){
												this.x = x;
												this.y = y;
												this.z = z;
												this.l = l;
											}
										}
										boolean isPossible(long n,long mid,long in) {
											long mi = mid;
											long y = (mi * (mi +1))/2;
											
											if(mid <= in) {
												if(y >= n) {
													return true;
												}
												return false;
											}else {
												long diff = mid - in;
												if(diff % 2 == 0) {
													long n1 = diff/2 + 1;
													long sum = (n1 * diff)/2;
													if(y - sum >= n) {
														return true;
													}
													return false;
												}else {
													long n1 = (diff - 1)/2 + 1;
													long sum = (n1 * (diff + 1))/2;
													if(y - sum >= n) {
														return true;
													}
													return false;
												}
											}
										}
										static class Pair implements Comparable<Pair>{
											int a ;
											int b;
											int c;
											Pair (int c,int a,int b){
												this.a = a;
												this.b = b;
												this.c = c;
											}
											public int compareTo(Pair p){
												return Integer.compare(p.c,this.c);
											}
										}
						}