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.

// Problem : E. Common Number
// Contest : Codeforces Round #608 (Div. 2)
// URL : https://codeforces.com/contest/1271/problem/E
// Memory Limit : 256.000000MB 
// Time Limit : 2000.000000milisec 
// Powered by CP Editor (https://github.com/coder3101/cp-editor2)

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.util.StringTokenizer;
import java.util.Arrays;
import java.util.List;

public class a {

  public static void main(String[] args) {
    InputReader in = new InputReader(System.in);
    PrintWriter out = new PrintWriter(System.out);
    
    Task solver = new Task();
    solver.solve(1, in, out);
    
    out.close();
  }
  
  static class Task {
    
    private long n;
    private long k;
    
    public void solve(int testNumber, InputReader in, PrintWriter out) {
      n = in.nextLong();
      k = in.nextLong();
      
      long lo = 1, hi1 = n / 2;
      while (lo <= hi1) {
        long mi = hi1 - (hi1 - lo) / 2;
        if (count (2 * mi) >= k)
          lo = mi + 1;
        else hi1 = mi - 1;
      }
      
      lo = 1;
      long hi2 = n / 2 + 1;
      while (lo <= hi2) {
        long mi = hi2 - (hi2 - lo) / 2;
        if (count (2 * mi - 1) >= k)
          lo = mi + 1;
        else hi2 = mi - 1;
      }
      
      hi1 *= 2;
      hi2 = hi2 * 2 - 1;
      if (hi1 == 0)
        hi1 = 1;
        
      out.println(hi1 > hi2 ? hi1 : hi2);
    }
    
    private long count(long x) {
      long sol = 0;
      long pow = 1;
      if ((x & 1) == 1 && 2 * x <= n) {
        x *= 2;
        ++sol;
      }
      while (x <= n) {
        long temp = 1;
        long nr = (temp << pow);
        if (x + nr <= n) {
          x *= 2;
          sol += nr;
          ++pow;
        } else {
          sol += n - x + 1;
          break;
        }
      }
      return sol;
    }
  }
  
  static class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;
    
    public InputReader(InputStream stream) {
      reader = new BufferedReader(new InputStreamReader(stream), 32768);
      tokenizer = null;
    }
    
    public String next() {
      while (tokenizer == null || !tokenizer.hasMoreTokens()) {
        try {
          tokenizer = new StringTokenizer(reader.readLine());
        } catch (IOException e) {
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    
    public int nextInt() {
      return Integer.parseInt(next());
    }
    
    public long nextLong() {
      return Long.parseLong(next());
    }
  }
}