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.
def zip_sorted(a,b): return zip(*sorted(zip(a,b)))[0],zip(*sorted(zip(a,b)))[1]
def gcd(a,b): return math.gcd(a,b)
def lcm(a,b): return ((a*b)//math.gcd(a,b))
def ncr(n,r): return math.comb(n,r)
def npr(n,r): return (math.factorial(n)//math.factorial(n-r))
def decimal_to_binary(n): return bin(n).replace("0b", "")
def binary_to_decimal(s): return int(s,2)

import sys, os.path
import math
from collections import defaultdict,deque

input = sys.stdin.readline

I = lambda : list(map(int,input().split()))
S = lambda : list(map(str,input1()))

def binary_odd(x):

	pow1 = 0
	sum1 = 0
	while (2**pow1)*x<=n:
		# print(x,(2**pow1)*x+((2**pow1)-1))
		if (2**pow1)*x+((2**pow1)-1)<=n:
			sum1+=(2**pow1)
		else:
			sum1+=(n-(2**pow1)*x+1)
			break
		pow1+=1
	return sum1>=k

def binary_even(x):

	pow1 = 0
	sum1 = 0
	while (2**pow1)*x<=n:
		if (2**pow1)*x+((2*(2**pow1))-1)<=n:
			sum1+=(2*(2**pow1))
		else:
			sum1+=(n-(2**pow1)*x+1)
			break
		pow1+=1
	return sum1>=k

def find_even_x(n1):

	start = 2
	end   = n1
	ans   = -1
	while start<=end:
		mid = (start+end)//2
		if mid%2!=0:
			mid = mid+1
		if binary_even(mid):
			ans   = mid
			start = mid+2
		else:
			end   = mid-2
	return ans

def find_odd_x(n1):

	start = 1
	end   = n1
	ans   = -1
	while start<=end:
		mid = (start+end)//2
		if mid%2==0:
			mid = mid+1
		if binary_odd(mid):
			ans   = mid
			start = mid+2
		else:
			end   = mid-2
	return ans

t = 1
for t1 in range(t):
	n,k = I()
	if n%2==0:
		x1 = find_even_x(n)
		x2 = find_odd_x(n-1)
	else:
		x1 = find_even_x(n-1)
		x2 = find_odd_x(n)
	# print(x1,x2)
	if x1==-1:
		print(x2)
	elif x2==-1:
		print(x1)
	else:
		print(max(x1,x2))

