Vasya will fancy any number as long as it is an integer power of two. Petya, on the other hand, is very conservative and only likes a single integer p (which may be positive, negative, or zero). To combine their tastes, they invented p-binary numbers of the form 2^x + p, where x is a non-negative integer.

For example, some -9-binary ("minus nine" binary) numbers are: -8 (minus eight), 7 and 1015 (-8=2^0-9, 7=2^4-9, 1015=2^{10}-9).

The boys now use p-binary numbers to represent everything. They now face a problem: given a positive integer n, what's the smallest number of p-binary numbers (not necessarily distinct) they need to represent n as their sum? It may be possible that representation is impossible altogether. Help them solve this problem.

For example, if p=0 we can represent 7 as 2^0 + 2^1 + 2^2.

And if p=-9 we can represent 7 as one number (2^4-9).

Note that negative p-binary numbers are allowed to be in the sum (see the Notes section for an example).

Input

The only line contains two integers n and p (1 ≤ n ≤ 10^9, -1000 ≤ p ≤ 1000).

Output

If it is impossible to represent n as the sum of any number of p-binary numbers, print a single integer -1. Otherwise, print the smallest possible number of summands.

Examples

Input


24 0


Output


2


Input


24 1


Output


3


Input


24 -1


Output


4


Input


4 -7


Output


2


Input


1 1


Output


-1

Note

0-binary numbers are just regular binary powers, thus in the first sample case we can represent 24 = (2^4 + 0) + (2^3 + 0).

In the second sample case, we can represent 24 = (2^4 + 1) + (2^2 + 1) + (2^0 + 1).

In the third sample case, we can represent 24 = (2^4 - 1) + (2^2 - 1) + (2^2 - 1) + (2^2 - 1). Note that repeated summands are allowed.

In the fourth sample case, we can represent 4 = (2^4 - 7) + (2^1 - 7). Note that the second summand is negative, which is allowed.

In the fifth sample case, no representation is possible.
n, p = [int(i) for i in input().split()]

def g(x: int, k: int)-> list:
    q = bin(x)[2:][::-1]
    r1, r2, r3, r = [], [], [], []
    
    s = sum(map(int, list(q)))
    #input(f'\t{q}\n\t{s}')
    i = len(q)-1 # i -- разряд, с которым мы будем работать (идём справа налево)
    while s < k: # пока нам не хватает единичек
        qq = int(q[i])*2 + int(q[i-1]) # считаем, сколько получим единичек из разряда i
        
        ost = '' # то, что идёт после i-того разряда
        if len(q[i:]) > 1: # если мы рассматриваем непоследний разряд
            ost = '0'+q[i+1:] # нужно не забыть про разряды, идущие после рассматриваемого

        
        s = sum(map(int, list(q[:i-1] + ost))) # находим количество единиц без qq
        input(f'\t(до) q = {q}\n\ti = {i}, s = {s}, qq = {qq}\n')
        
        if s + qq > k: # может получиться так, что мы сделаем больше единиц, чем нужно
            i -= 1 # если единичек получиться больше, чем надо
            continue # переходим на следующий разряд
        
        q = q[:i-1] + str(qq) + ost # получаем результат
        
        i -= 1 # переходим на следющий разряд
        s = sum(map(int, list(q))) # пересчитываем полученное количество единиц 
        input(f'\t(после) q = {q}\n\ti = {i}, s = {s}, qq = {qq}\n')
        
    for i in range(len(q)): # рассматриваем каждый разряд q
        j = int(q[i]) # количество единичек в рассматриваемом разряде (степеней двойки)
        if j >= 1: # каждую единичку нужно записать как степень двойки
            # для вывода ответа
            r += [f'2^{i}'] * j
            # для проверки на вычислительную ошибку 
            r1.append(f"{['',f'{j}*'][j>1]}" + f'2^{i}')
            r2.append(f"{['',f'{j}*'][j>1]}" + f'{2**i}')
            r3.append(f'{j*2**i}')

    return r[::-1], r1, r2, r3 # берём r[::-1], чтобы степени двойки шли по невозрастанию
'''
Число n можно разложить так:
n = b + kp, где k -- количество p-двоичных чисел (какое-то целое число)
                b -- число, у которого количество единичек в 2СС = k
'''

# если вдруг n -- отрицательное число, или n=p=0, то программа не имеет смысла
if n < 0 or n==0 and p==0: 
    exit('-1')

# Рассмотрим p = 0.
# n = b => чтобы узнать k, нужно просто посчитать единицы у n в 2СС
if p == 0:
    print(bin(n).count('1'))

# Рассмотрим p != 0: n = b + kp => 

# => k = (n-b)/p

# Заметим, что n = b + kp при n=1, p=1: 1 = b + k, но b>=1 и k>=1 => 
# подобные значения должны отсеиваться.

# Найдём ограничения значений n и p.
# k,b >= 1
# k = (n-b)/p => (n-b)/p >= 1|*p =>
# n - b >= p, 
# n - p >= b >= 1 
# n - p >= 1

else: # if p != 0:
    b = n # чтобы просто объявить b (здесь могла быть ваша реклама)
    k = -1 # делаем начальное значение k невозможным для первой итерации
    z = p/abs(p) # знак числа p (нужен, чтобы уместить два условия в одном)

    if n - p >= 1: # входные данные должны удовлетворять условию

        while (b + k*p)*z > n*z or k==-1: # подбираем (k, b), ближайшие к n
            b -= p # меняем b = n - kp, взяв следующее возможное b
            b2 = bin(b)[2:]
            k = b2.count('1')
            #input(f'{b} + {k}*{p} = {b+k*p} != {n} {["(н)","(в)"][b+k*p!=n]}')
        k = (n-b)//p
        
        
        #r, *hh = g(b, k)
        '''Поэтапный вывод ответа
        for h in hh:
            input(f'{n} = {" + ".join(h)} + {k}*{p} {["(н)","(в)"][b+k*p==n]}')
        #'''
        '''Красивый вывод ответа
        answer = ''
        ps = [f' - {abs(p)})', f' + {abs(p)})'][p>0]
        for v in range(k): # записываем k p-двоичных чисел в answer
            answer += f' + ({r[v]}' + ps # p-двоичное число состоит из 2^x (r[v]) и p

        print(f'{n} = {answer[3:]}') # выводим без " + " в начале ответа
        #'''
        if b >= k: # кол-во 1 в дв. записи числа не может быть больше числа
            print(k)
        else:
            print(-1)
    else:
        print(-1)
    
'''
else:
    b = n-p
    k = b

    while b + k*p < n:
        b -= p
        b2 = bin(b)[2:]
        k = b2.count('1')
    print(m)
#'''
'''
k = (n - b)/p
print(k)
#'''