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.
#include <bits/stdc++.h>
using std::bitset;
using std::cerr;
using std::cin;
using std::cout;
using std::deque;
using std::endl;
using std::fill;
using std::fixed;
using std::ios_base;
using std::iterator;
using std::map;
using std::max_element;
using std::min_element;
using std::multimap;
using std::multiset;
using std::pair;
using std::queue;
using std::reverse;
using std::set;
using std::setprecision;
using std::sort;
using std::stable_sort;
using std::stack;
using std::string;
using std::swap;
using std::unique;
using std::vector;
long long min(long long a, long long b) { return a < b ? a : b; }
long long min(int a, long long b) { return a < b ? a : b; }
long long min(long long a, int b) { return a < b ? a : b; }
long long min(int a, int b) { return a < b ? a : b; }
long long max(long long a, long long b) { return a > b ? a : b; }
long long max(int a, long long b) { return a > b ? a : b; }
long long max(long long a, int b) { return a > b ? a : b; }
long long max(int a, int b) { return a > b ? a : b; }
namespace MySpace {};
struct Node {
  int x, y;
  long long summ;
  int sz;
  Node *L, *R;
};
Node *NewNode(int x) {
  Node *R = new Node();
  R->summ = x;
  R->x = x;
  R->y = (1 << 15) * rand() + rand();
  R->sz = 1;
  return R;
}
void describe(Node *Nd) {
  if (!Nd) return;
  describe(Nd->L);
  cout << Nd->x << " ";
  describe(Nd->R);
}
int get_sz(Node *Nd) {
  if (Nd) return Nd->sz;
  return 0;
}
long long get_summ(Node *Nd) {
  if (Nd) return Nd->summ;
  return 0;
}
long long update(Node *Nd) {
  Nd->summ = Nd->x + get_summ(Nd->L) + get_summ(Nd->R);
  Nd->sz = 1 + get_sz(Nd->L) + get_sz(Nd->R);
}
Node *Merge(Node *L, Node *R) {
  if (!L) return R;
  if (!R) return L;
  if (L->y < R->y) {
    L->R = Merge(L->R, R);
    update(L);
    return L;
  } else {
    R->L = Merge(L, R->L);
    update(R);
    return R;
  }
}
pair<Node *, Node *> Split(Node *Scope, int k) {
  if (!Scope) return {nullptr, nullptr};
  if (Scope->x <= k) {
    pair<Node *, Node *> a = Split(Scope->R, k);
    Scope->R = a.first;
    update(Scope);
    return {Scope, a.second};
  } else {
    pair<Node *, Node *> a = Split(Scope->L, k);
    Scope->L = a.second;
    update(Scope);
    return {a.first, Scope};
  }
}
pair<Node *, Node *> SplitSize(Node *Scope, int k) {
  if (!Scope) return {nullptr, nullptr};
  if (get_sz(Scope->L) < k) {
    pair<Node *, Node *> a = SplitSize(Scope->R, k - get_sz(Scope->L) - 1);
    Scope->R = a.first;
    update(Scope);
    return {Scope, a.second};
  } else {
    pair<Node *, Node *> a = SplitSize(Scope->L, k);
    Scope->L = a.second;
    update(Scope);
    return {a.first, Scope};
  }
}
void Add(Node *&Root, int x) {
  Node *Nd = NewNode(x);
  pair<Node *, Node *> a = Split(Root, x);
  a.first = Merge(a.first, Nd);
  Root = Merge(a.first, a.second);
}
const long long INF = 1e14;
signed main() {
  srand(time(NULL));
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  long long n, p;
  cin >> n >> p;
  if (p == 0) {
    cout << __builtin_popcount(n);
    return 0;
  }
  long long R = 1;
  for (long long alpha = R; alpha <= R + 100000; alpha++) {
    long long kek = n - alpha * p;
    if (kek >= alpha && __builtin_popcount(kek) <= alpha) {
      cout << alpha;
      return 0;
    }
  }
  cout << -1;
  return 0;
}
