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.util.ArrayList;
import java.util.StringTokenizer;

import static java.lang.Math.max;

public class Main {
    long n;
    int log;
    ArrayList<Long> al;

    int get_start(long x) {
        int ans = 0;
        while (x > 0) {
            x /= 2;
            ans++;
        }
        return ans;
    }

    long cnt(long x, long col, long ans, int start) {
        if (x > n) return 0;
        if (start == log) return ans;
        if (col + start < log) {
            ans += ((long) 1 << col);
            return cnt(x, col + 1, ans, start);
        } else {
            ArrayList<Long> t1 = new ArrayList<>();
            while (x > 0) {
                t1.add(x % 2);
                x /= 2;
            }
            ArrayList<Long> t = new ArrayList<>();
            for (int i = t1.size() - 1; i >= 0; i--) {
                t.add(t1.get(i));
            }
            while (t.size() < al.size()) t.add(0L);
            boolean is_more = false;
            boolean is_less = false;
            for (int i = 0; i < start; i++) {
                if (al.get(i) > t.get(i)) {
                    is_less = true;
                    break;
                }
                if (al.get(i) < t.get(i)) {
                    is_more = true;
                    break;
                }
            }
            if (is_more) return ans;
            if (is_less) return ans + ((long) 1 << col);
            boolean all_zeros = true;
            for (int i = start; i < t.size() - 1; i++) {
                if (al.get(i) == 0) continue;
                all_zeros = false;
                ans += ((long) 1 << (long) (log - i - 1));
            }
            if (al.get(al.size() - 1) == 1) ans += 2;
            else if (al.get(al.size() - 1) == 0 && !all_zeros) ans++;
            return ans + (all_zeros ? 1 : 0);
        }
    }

    void run() throws IOException {
        n = nextLong();
        long k = nextLong();
        al = new ArrayList<>();
        long x = n;
        ArrayList<Long> al1 = new ArrayList<>();
        while (x > 0) {
            al1.add(x % 2);
            x /= 2;
        }
        al = new ArrayList<>();
        for (int i = al1.size() - 1; i >= 0; i--) {
            al.add(al1.get(i));
        }
        log = al.size();
        long l = 1;
        long r = n + 2;
        while (l + 2 < r) {
            long m = (l + r) / 2;
            if (m % 2 == 0) m++;
            if (cnt(m, 1, 1, get_start(m)) >= k) l = m;
            else r = m;
        }
        long l1 = 1;
        long r1 = n + 2;
        while (l1 + 2 < r1) {
            long m = (l1 + r1) / 2;
            if (m % 2 != 0) m++;
            if (cnt(m, 1, 1, get_start(m)) + cnt(m + 1, 1, 1, get_start(m + 1)) >= k) l1 = m;
            else r1 = m;
        }
        pw.print(max(l, l1));
        pw.close();
    }

    class point implements Comparable<point> {
        int x, y;

        public point(int a, int b) {
            x = a;
            y = b;
        }

        @Override
        public int compareTo(point o) {
            if (o.y == this.y) return Integer.compare(o.x, this.x);
            return -Integer.compare(o.y, this.y);
        }

    }

    long mod = (long) 1e9 + 7;
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    //BufferedReader br = new BufferedReader(new FileReader("qual.in"));

    StringTokenizer st = new StringTokenizer("");
    PrintWriter pw = new PrintWriter(System.out);
    //PrintWriter pw = new PrintWriter("qual.out");

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

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

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

    double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public Main() throws FileNotFoundException {
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}