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.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

public class P1271E
{
	public static void main(String[] args)
	{
		FastScanner scan = new FastScanner();
		long n = scan.nextLong();
		long k = scan.nextLong();
		ArrayList<Long> cand = new ArrayList<>();
		long curr = n;
		while (curr > 0)
		{
			for (int i = 0; i < 4; i++)
				cand.add(curr - i);
			if (curr > 3)
			{
				cand.add(Long.highestOneBit(curr)-1);
				cand.add(Long.highestOneBit(curr)-2);
			}
			curr /= 2;
		}
		int bits = numBits(n);
		Collections.sort(cand, Collections.reverseOrder());
		long max = 0;
		for (int i = 0; i < cand.size(); i++)
		{
			long num = cand.get(i);
			if (num > n || n < 1)
				continue;
			long occ = 0;
			int candBits = numBits(num);
			for (int j = candBits; j < bits; j++)
			{
				int diff = j-candBits;
				occ += 1L << diff;
				if (num % 2 == 0)
					occ += 1L << diff;
			}
			int diff = bits-candBits;
			long start = num << diff;
			long end = num % 2 == 0 ? ((num+2) << diff) - 1 : ((num+1) << diff) - 1;
			end = Math.min(end, n);
			if (start <= end)
				occ += end-start + 1;
			if (occ >= k)
			{
				max = num;
				break;
			}
		}
		System.out.println(max);
	}
	private static int numBits(long num)
	{
		return Long.bitCount(Long.highestOneBit(num)-1)+1;
	}
	static class FastScanner
	{
		BufferedReader br;
		StringTokenizer st;

		public FastScanner()
		{
			try
			{
				br = new BufferedReader(new InputStreamReader(System.in));
				st = new StringTokenizer(br.readLine());
			} catch (Exception e)
			{
				e.printStackTrace();
			}
		}

		public String next()
		{
			if (st.hasMoreTokens())
				return st.nextToken();
			try
			{
				st = new StringTokenizer(br.readLine());
			} catch (Exception e)
			{
				e.printStackTrace();
			}
			return st.nextToken();
		}

		public int nextInt()
		{
			return Integer.parseInt(next());
		}

		public long nextLong()
		{
			return Long.parseLong(next());
		}

		public String nextLine()
		{
			String line = "";
			try
			{
				line = br.readLine();
			} catch (Exception e)
			{
				e.printStackTrace();
			}
			return line;
		}
	}
}
