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 random     #libreria_necesaria_para_generar_numeros_de_forma_aleatoria


# __________________________________________________#
# brute force solution_____________________________#
def solve_1(n, k):
    frequency = [0] * n       #array_que_representa_en_cuantos_path_esta_contenido_el_numero_i
    frequency[0] = n         #el_1_pertenece_a_todos_los_path
    for i in range(1, n + 1):    #calculando_path(i)_para_todo_numero_desde_1_hasta_n
        path(i, frequency)

    maximum = 1               #representa_el_mayor_valor_contenido_en_al_menos_k_path
    for i in range(n):           #analizando_todos_los_numeros_para_tomar_el_mayor_con_frequency_mayor_o_igual_que_k
        if frequency[i] >= k:
            maximum = i + 1
    return maximum        #mayor_valor_contenido_en_al_menos_k_path

def path(x, frequency):      #calculando_el_path_de_un_elemento_x
    while x > 1:               #inicia_en_x
        frequency[x - 1] += 1       #como_x_pertence_al_path_del_numero_inicial_se_aumenta_en_1_su_frecuencia
        x = function(x)            #x_toma_valor_f(x)
    return

def function(x):          #funcion_descrita_en_el_problema
    if x % 2 == 0:      #cuando_x_par
        return x // 2
    return x - 1        #cuando_x_impar


# __________________________________________________#
# solution_________________________________________#
def solve_2(n, k):
    max_even = binary_search(n, k, 0, n, 0)         #busqueda_binaria_en_numeros_pares
    max_odd = binary_search(n, k, 0, n, 1)          #busqueda_binaria_en_numeros_impares
    return max(max_even, max_odd)                   #maximo_entre_pares_e_impares

def binary_search(n, k, l, r, parity):       #algoritmo_busqueda_binaria
    max_contained = 0
    if k == n: return 1             #unico_valor_que_se_repite_n_veces_es_1

    while r - l > 1:               #mientras_existan_numeros_en_el_intervalo
        m = (r + l) // 2           #elemento_en_la_mitad
        if m % 2 == (not parity): m += 1      #cuando_m_no_tiene_la_paridad_deseada_el_sucesor_si_la_tendra

        if not parity:                                 #calculando_count_en_dependencia_de_la_paridad
            count = calculate_count_even(n, m)         #
        else: count = calculate_count_odd(n, m)        #

        if count >= k:                                #cuando_m_esta_contenido_en_al_menos_k_path...
            max_contained = max(max_contained, m)     #es_el_maximo_hasta_el_momento...
            l = m                                     #entonces_se_analizan_los_mayores_que_m
        else: r = m - 2              #sino_se_analizan_los_menores

    return max_contained        #mayor_par/impar_contenido_en_al_menos_k_path

def calculate_count_odd(n, x):   #calculo_del_count_de_un_numero_impar
    if x == 1: return n     #el_1_pertenece_a_los_n_path
    count, a = 0, 1

    while a * x <= n:     #contando_todos_los_path_a_los_que_pertenece_x_menores_que_n
        p = (a * x) + (a - 1)
        if p <= n:
            count += a
            a *= 2
        else:
            count += n - (a * x) + 1
            break

    return count  #cantidad_de_path_a_los_que_pertenece_x

def calculate_count_even(n, x):    #calculo_del_count_de_un_numero_par
    if x == 2: return n - 1       #el_2_pertenece_a_n-1_path
    count, a = 0, 1

    while (a * x) <= n:           #contando_todos_los_path_a_los_que_pertenece_x_menores_que_n
        p = (a * x) + ((2 * a) - 1)
        if p <= n:
            count += 2 * a
            a *= 2
        else:
            count += n - (a * x) + 1
            break

    return count   #cantidad_de_path_a_los_que_pertenece_x


# __________________________________________________#
# main_____________________________________________#
def main():
    n, k = [int(i) for i in input().split()]          #valores_entrada_al_problema
    #print(solve_1(n, k))          #solucion_fuerza_bruta
    print(solve_2(n, k))          #solucion_eficiente
    return


# __________________________________________________#
# random cases tester______________________________#
def random_cases():
    case = [0] * 2
    case_generator(case)      #generando_n_y_k_aleatorios
    print('Case: \n' + 'n = ' + str(case[0]) + '  ' + 'k = ' + str(case[1]))
    #print(solve_1(case[0], case[1]))    #solucion_fuerza_bruta_en_n_y_k_aleatorios
    print(solve_2(case[0], case[1]))     #solucion_eficiente_en_n_y_k_aleatorios
    return

def case_generator(case):
    case[0] = random.randint(1, 1000)       #valor_de_n_aleatorio
    case[1] = random.randint(1, case[0])    #valor_de_k_aleatorio_menor_o_igual_que_n
    return


# __________________________________________________#
# tester___________________________________________#
def tester():
    for i in range(1, 20):      #cantidad_de_casos_que_se_desean_probar
        case = [0] * 2
        case_generator(case)    #generando_n_y_k_aleatorios
        s1 = solve_1(case[0], case[1])    #solucion_fuerza_bruta_en_n_y_k
        s2 = solve_2(case[0], case[1])    #solucion_eficiente_en_n_y_k

        print('Case ' + str(i) + ':\n' + 'n = ' + str(case[0]) + '   k = ' + str(case[1]))
        print('solucion fuerza bruta : ' + str(s1))  #solucion_fuerza_bruta
        print('solucion eficiente : ' + str(s2))     #solucion_eficiente

        if s1 != s2:      #ambas_soluciones_no_coinciden_por_tanto_la_solucion_eficiente_esta_mal
            print('Wrong Answer\n')
            return
        print('Accepted\n')     #ambas_soluciones_coinciden_por_tanto_la_solucion_eficiente_resulto_bien
    return


main()              #entrada_de_casos_por_consola
#random_cases()     #caso_aleatorio
#tester()           #comprobar_solucion_eficiente_contra_solucion_fuerza_bruta
