At first, let's define function f(x) as follows: $$$ \begin{matrix} f(x) & = & \left\{ \begin{matrix} x/2 & \mbox{if } x  is even \\\ x - 1 & \mbox{otherwise } \end{matrix} \right. \end{matrix} $$$

We can see that if we choose some value v and will apply function f to it, then apply f to f(v), and so on, we'll eventually get 1. Let's write down all values we get in this process in a list and denote this list as path(v). For example, path(1) = [1], path(15) = [15, 14, 7, 6, 3, 2, 1], path(32) = [32, 16, 8, 4, 2, 1].

Let's write all lists path(x) for every x from 1 to n. The question is next: what is the maximum value y such that y is contained in at least k different lists path(x)?

Formally speaking, you need to find maximum y such that \left| \{ x ~|~ 1 ≤ x ≤ n, y ∈ path(x) \} \right| ≥ k.

Input

The first line contains two integers n and k (1 ≤ k ≤ n ≤ 10^{18}).

Output

Print the only integer — the maximum value that is contained in at least k paths.

Examples

Input


11 3


Output


5


Input


11 6


Output


4


Input


20 20


Output


1


Input


14 5


Output


6


Input


1000000 100


Output


31248

Note

In the first example, the answer is 5, since 5 occurs in path(5), path(10) and path(11).

In the second example, the answer is 4, since 4 occurs in path(4), path(5), path(8), path(9), path(10) and path(11).

In the third example n = k, so the answer is 1, since 1 is the only number occuring in all paths for integers from 1 to 20.


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.math.BigInteger;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

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

    static class Task {
    	public boolean check(long x,long n,long k) {
    		if(x%2==1) {
    			long a=x;
    			long ans=1;
    			String temp=Long.toBinaryString(x);
    			int len=Long.toBinaryString(n).length();
    			for(int i=temp.length()+1;i<len;i++) {
    				ans+=1l<<(i-temp.length());
    			}
    			/*if(a==11)
    				System.out.println(ans+" "+x+" "+n);*/
    			if(len-temp.length()>=0) {
    				x<<=(len-temp.length());
        			/*if(a==11)
        				System.out.println(x);*/
        			if(x<=n) {
        				ans+=Math.min(1l<<(len-temp.length()), n-x+1);
        				if(Long.toBinaryString(a).length()==len)
            				ans--;
        			}
    			}
    			
    			/*if(a==11)
    				System.out.println(ans);*/
    			return ans>=k;
    		}
    		else {
    			long a=x;
    			long ans=1;
    			long y=x+1;
    			if(y<=n)
    				ans++;
    			String temp=Long.toBinaryString(y);
    			int len=Long.toBinaryString(n).length();
    			for(int i=temp.length()+1;i<len;i++)
    				ans+=1l<<(i-temp.length());
    			boolean flag=false;
    			if(temp.length()<=len) {
    				y<<=(len-temp.length());
        			if(y<=n){
        				ans+=Math.min(1l<<(len-temp.length()), n-y+1);
        				if(Math.min(1l<<(len-temp.length()), n-y+1)==n-y+1)
        					flag=true;
        				if(Long.toBinaryString(a).length()==len)
            				ans--;
        			}
        			
        			
    			}
    		/*	if(a==10)
    				System.out.println(ans);*/
    			temp=Long.toBinaryString(x);
    			for(int i=temp.length()+1;i<len;i++)
    				ans+=1l<<(i-temp.length());
    			/*if(a==10)
    				System.out.println(ans);*/
    			if(temp.length()<=len) {
    				x<<=(len-temp.length());
        			if(x<=n) {
        				if(!flag)
            				ans+=Math.min(1l<<(len-temp.length()), n-x+1);
        				else

            				ans+=Math.min(1l<<(len-temp.length()), n-x);
        			}
        			if(Long.toBinaryString(a).length()==len)
        				ans--;
    			}
    			/*if(a==10)
    				System.out.println(ans);*/
    			return ans>=k;
    		}
    	}
    	
        public void solve(int testNumber, InputReader sc, PrintWriter out) throws IOException {
        	long n=sc.nextLong();
        	long k=sc.nextLong();
       /* 	System.out.println(Long.toBinaryString(n));
        	System.out.println(Long.toBinaryString(6));
        	check(31248,n,k);*/
        	
        	long l=0;
        	long r=(n%2==0)?n/2-1:n/2;
        	long ans=1;
        	while(l<=r) {
        		long mid=(l+r)>>1;
        		long x=mid*2+1;
        		if(check(x,n,k)) {
        			ans=x;
        			l=mid+1;
        		}
        		else
        			r=mid-1;
        	}
        	l=0;
        	r=n/2;
        	while(l<=r) {
        		long mid=(l+r)>>1;
        		long x=mid*2;
        		if(check(x,n,k)) {
        			ans=Math.max(ans, x);
        			l=mid+1;
        		}
        		else
        			r=mid-1;
        	}
        	out.println(ans);
        }
    }

    static class InputReader{
        StreamTokenizer tokenizer;
        public InputReader(InputStream stream){
            tokenizer=new StreamTokenizer(new BufferedReader(new InputStreamReader(stream)));
            tokenizer.ordinaryChars(33,126);
            tokenizer.wordChars(33,126);
        }
        public String next() throws IOException {
            tokenizer.nextToken();
            return tokenizer.sval;
        }
        public int nextInt() throws IOException {
            return Integer.parseInt(next());
        }
        public long nextLong() throws IOException {
            return Long.parseLong(next());
        }
        public boolean hasNext() throws IOException {
            int res=tokenizer.nextToken();
            tokenizer.pushBack();
            return res!=tokenizer.TT_EOF;
        }
        
        public double nextDouble() throws NumberFormatException, IOException {
        	return Double.parseDouble(next());
        }
        
        public BigInteger nextBigInteger() throws IOException {
        	return new BigInteger(next());
        }
    }
}
