#include <bits/stdc++.h>   using namespace std;   using ll = long long;   using vi = vector<int>;   using vvi = vector<vi>;   using vll = vector<ll>;   using vvll = vector<vll>;   using vb = vector<bool>;   using vd = vector<double>;   using vs = vector<string>;   using pii = pair<int, int>;   using pll = pair<ll, ll>;   using pdd = pair<double, double>;   using vpii = vector<pii>;   using vvpii = vector<vpii>;   using vpll = vector<pll>;   using vvpll = vector<vpll>;   using vpdd = vector<pdd>;   using vvpdd = vector<vpdd>;   template <typename T>   void ckmin(T& a, const T& b) {     a = min(a, b);   }   template <typename T>   void ckmax(T& a, const T& b) {     a = max(a, b);   }   mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());   namespace __input {   template <class T1, class T2>   void re(pair<T1, T2>& p);   template <class T>   void re(vector<T>& a);   template <class T, size_t SZ>   void re(array<T, SZ>& a);   template <class T>   void re(T& x) {     cin >> x;   }   void re(double& x) {     string t;     re(t);     x = stod(t);   }   template <class Arg, class... Args>   void re(Arg& first, Args&... rest) {     re(first);     re(rest...);   }   template <class T1, class T2>   void re(pair<T1, T2>& p) {     re(p.first, p.second);   }   template <class T>   void re(vector<T>& a) {     for (int i = 0; i < (int((a).size())); i++) re(a[i]);   }   template <class T, size_t SZ>   void re(array<T, SZ>& a) {     for (int i = 0; i < (SZ); i++) re(a[i]);   }   }  // namespace __input   using namespace __input;   namespace __output {   template <class T1, class T2>   void pr(const pair<T1, T2>& x);   template <class T, size_t SZ>   void pr(const array<T, SZ>& x);   template <class T>   void pr(const vector<T>& x);   template <class T>   void pr(const set<T>& x);   template <class T1, class T2>   void pr(const map<T1, T2>& x);   template <class T>   void pr(const T& x) {     cout << x;   }   template <class Arg, class... Args>   void pr(const Arg& first, const Args&... rest) {     pr(first);     pr(rest...);   }   template <class T1, class T2>   void pr(const pair<T1, T2>& x) {     pr( { , x.first,  ,  , x.second,  } );   }   template <class T, bool pretty = true>   void prContain(const T& x) {     if (pretty) pr( { );     bool fst = 1;     for (const auto& a : x) pr(!fst ? pretty ?  ,   :     :   , a), fst = 0;     if (pretty) pr( } );   }   template <class T>   void pc(const T& x) {     prContain<T, false>(x);     pr(  n );   }   template <class T, size_t SZ>   void pr(const array<T, SZ>& x) {     prContain(x);   }   template <class T>   void pr(const vector<T>& x) {     prContain(x);   }   template <class T>   void pr(const set<T>& x) {     prContain(x);   }   template <class T1, class T2>   void pr(const map<T1, T2>& x) {     prContain(x);   }   void ps() { pr(  n ); }   template <class Arg>   void ps(const Arg& first) {     pr(first);     ps();   }   template <class Arg, class... Args>   void ps(const Arg& first, const Args&... rest) {     pr(first,    );     ps(rest...);   }   }  // namespace __output   using namespace __output;   namespace __algorithm {   template <typename T>   void dedup(vector<T>& v) {     sort((v).begin(), (v).end());     v.erase(unique((v).begin(), (v).end()), v.end());   }   template <typename T>   typename vector<T>::iterator find(vector<T>& v, const T& x) {     auto it = lower_bound((v).begin(), (v).end(), x);     return it != v.end() && *it == x ? it : v.end();   }   template <typename T>   size_t index(vector<T>& v, const T& x) {     auto it = find(v, x);     assert(it != v.end() && *it == x);     return it - v.begin();   }   template <typename C, typename T>   vector<T> prefixes(const C& v, T zero) {     vector<T> res(int((v).size()) + 1, zero);     for (int i = 0; i < (int((v).size())); i++) res[i + 1] = res[i] + v[i];     return res;   }   template <typename C, typename T>   vector<T> suffixes(const C& v, T zero) {     vector<T> res(int((v).size()) + 1, zero);     for (int i = (int((v).size())) - 1; i >= 0; i--) res[i] = v[i] + res[i + 1];     return res;   }   }  // namespace __algorithm   using namespace __algorithm;   struct monostate {     friend istream& operator>>(istream& is,                                const __attribute__((unused)) monostate& ms) {       return is;     }     friend ostream& operator<<(ostream& os,                                const __attribute__((unused)) monostate& ms) {       return os;     }   } ms;   template <typename W = monostate>   struct wedge {     int u, v, i;     W w;     wedge<W>(int _u = -1, int _v = -1, int _i = -1) : u(_u), v(_v), i(_i) {}     int operator[](int loc) const { return u ^ v ^ loc; }     friend void re(wedge& e) {       re(e.u, e.v, e.w);       --e.u, --e.v;     }     friend void pr(const wedge& e) { pr(e.u,  <- , e.w,  -> , e.v); }   };   namespace __io {   void setIn(string second) { freopen(second.c_str(),  r , stdin); }   void setOut(string second) { freopen(second.c_str(),  w , stdout); }   void setIO(string second =   ) {     ios_base::sync_with_stdio(0);     cin.tie(0);     cout.precision(15);     if (int((second).size())) {       setIn(second +  .in ), setOut(second +  .out );     }   }   }  // namespace __io   using namespace __io;   template <size_t N>   struct sieve {     vi primes, least_prime, largest_proper, phi;     sieve() : least_prime(N + 1), largest_proper(N + 1), phi(N + 1) {       phi[1] = 1;       for (int i = 2; i <= N; i++) {         if (!least_prime[i]) {           least_prime[i] = i;           largest_proper[i] = 1;           primes.push_back(i);         }         phi[i] = phi[largest_proper[i]];         phi[i] *= least_prime[i] -                   int(least_prime[i] != least_prime[largest_proper[i]]);         for (int x : primes) {           if (x > least_prime[i] || i * x > N) break;           least_prime[i * x] = x;           largest_proper[i * x] = i;         }       }     }     bool is_prime(int v) {       assert(0 < v && v < N);       return least_prime[v] == v;     }     vi factor(int v) {       assert(0 < v && v <= N);       vi res;       while (v > 1) {         res.push_back(least_prime[v]);         v = largest_proper[v];       }       reverse((res).begin(), (res).end());       return res;     }     vi divisors(int v) {       if (v == 1) return {1};       int p = least_prime[v], m = 0;       while (v % p == 0) v /= p, m++;       vi res = divisors(v), fin;       for (int d : res)         for (int pc = 0, t = d; pc <= m; pc++, t *= p) fin.push_back(t);       return fin;     }   };   const int MAXV = 1e6 + 1;   sieve<MAXV> sv;   int main() {     setIO();     int N, K;     re(N, K);     if (K == 1) {       ps(3);       return 0;     }     nth_element(sv.phi.begin() + 3, sv.phi.begin() + 3 + K,                 sv.phi.begin() + N + 1);     ps(accumulate(sv.phi.begin() + 3, sv.phi.begin() + K + 3, 0ll) + 2);     return 0;   }