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.
/*package whatever //do not write package name here */
import java.util.*;
import java.io.*;

public class GFG {
	public static void main (String[] args) {
		Scanner sc = new Scanner(System.in);
		long n = sc.nextLong();
		long k = sc.nextLong();
		long high_even = ((n&1) != 0) ? n-1 : n;
		long high_odd = ((n&1) > 0) ? n : n-1;
		long res_even = bin_search(2, high_even, k, n, true);
		long res_odd = bin_search(1, high_odd, k, n, false);
		//System.out.println("49 100 " + count(49, 100));
		//System.out.println("even "+res_even+" odd "+res_odd);
		System.out.println(Math.max(res_odd, res_even));
	}
	
	static long bin_search(long low, long high, long k, long n, boolean even){
	    while (low < high){
	        long mid = (low + high) / 2;
	        if(even){
    	        if(mid % 2 == 0){
    	            //System.out.println("count of "+mid+" "+count(mid,n));
    	            if (count(mid, n) >= k ){
    	                low = mid;
    	            }else{
    	                high = mid - 2;
    	            }               
    	        }else{
    	            long c_left_mid = count(mid-1, n); 
    	            long c_right_mid = count(mid+1, n);
    	            //System.out.println("count "+(mid-1)+" "+c_left_mid+" count "+(mid+1)+" "+c_right_mid);
    	            if(c_left_mid < k){
    	                high = mid - 3;
    	            }else if(c_left_mid >= k && c_right_mid < k){
    	                return (mid-1);
    	            }else if(c_right_mid >= k){
    	                low = mid+1;
    	            }
    	        }
	        }else{
	            if(mid % 2 == 1){
    	            //System.out.println("count of "+mid+" "+count(mid,n));
    	            if (count(mid, n) >= k ){
    	                low = mid;
    	            }else{
    	                high = mid - 2;
    	            }               
    	        }else{
    	            long c_left_mid = count(mid-1, n); 
    	            long c_right_mid = count(mid+1, n);
    	            //System.out.println("count "+(mid-1)+" "+c_left_mid+" count "+(mid+1)+" "+c_right_mid);
    	            if(c_left_mid < k){
    	                high = mid - 3;
    	            }else if(c_left_mid >= k && c_right_mid < k){
    	                return (mid-1);
    	            }else if(c_right_mid >= k){
    	                low = mid+1;
    	            }
    	        }
	        }
	    }
	    
	    return (count(low, n) >= k) ? low : -1;
	}
	
	static long count(long x, long n){
	    long res = 0;
	    long mul = 1, even_margin = (mul*2) - 1, odd_margin = mul - 1;
	    long temp_x = x;
	    while(x <= n){
	        if(temp_x % 2 == 0){
	            if(n > x + even_margin){
	                res += even_margin + 1;
	            }else{
	                res += Math.max(0, n-x+1);
	            }
	        }else{
	            if(n > x + odd_margin){
	                res += odd_margin + 1;
	            }else{
	                res += Math.max(0, n-x+1);
	            }
	        }
	        mul *= 2;
	        even_margin = (mul*2) - 1;
	        odd_margin = mul - 1;
	        x = temp_x * mul;
	        //System.out.println("X "+x+" even_margin "+even_margin);
	    }
	    return res;
	}
}