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.*;
import java.math.BigInteger;
import java.util.*;

import static java.lang.Math.*;
import static java.util.Arrays.*;

public class Main {
    static long n;
    static long log;
    static long calc(long a) {
        long fa = a;
        long rt = 0;
        long lgt = getLength(a);
        for (long i = lgt + 1; i < log; i++) {
            rt += (1L << (i - lgt));
        }
        a <<= (log - lgt);
        int eql = 0;
        for (long i = log - 1; i >= log - lgt; i--) {
            if (getBit(a, i) != getBit(n, i)) {
                eql = getBit(a, i) > getBit(n, i) ? 1 : -1;
                break;
            }
        }
        if (eql == 1) return rt;
        if (eql == -1) return rt + (log == lgt ? 0 : (1L << (log - lgt)));
        long zrs = log - lgt;
        for (long i = log - lgt - 1; i >= 0; i--) {
            if (getBit(n, i) == 1) rt += ((1L << (zrs - 1L)));
            zrs--;
        }
        return rt + (fa == n ? 0L : 1L);
    }

    static long getBit(long a, long bit) {
        return (a >> bit) & 1L;
    }

    static long extraCalc(long a) {
            if ((a & 1) == 0) return calc(a) + ((a + 1L) <= n ? (calc(a + 1L) + 1L) : 0) + 1L;
             else return calc(a) + 1;
    }

    static long  getLength(long a) {
        for (long i = 63; i >= 0; i--) {
            if (getBit(a, i) == 1L) return i + 1L;
        }
        return 1L;
    }

    public static void main(String[] args) throws IOException {
        FastScanner in = new FastScanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        n = in.nextLong();
        log = getLength(n);
        long k = in.nextLong();
        long t = 0;
        while ((1L << t) <= n) ++t;
        long l = 0;
        while (t > 0) {
            while (t > 0 && ((l + (1L << t)) > n || extraCalc(l + (1L << t)) < k)) {
                t--;
            }
            if (t == 0) {
                if (extraCalc(l + 1) >= k && l + 1 <= n) l++;
            } else l = (l + (1L << t));
        }
        if (extraCalc(l + 1) >= k && l + 1 <= n) l++;
        if (extraCalc(l) < k || l > n) l--;
        out.println(l);
        out.close();
    }
}

class FastScanner {
    BufferedReader br;
    StringTokenizer st;

    FastScanner(File f) throws FileNotFoundException {
        br = new BufferedReader(new FileReader(f));
    }

    FastScanner(InputStream is) {
        br = new BufferedReader(new InputStreamReader(is));
    }

    String next() throws IOException {
        while (st == null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }

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

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