#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;
}
