#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


// a x + b y = (+/-) gcd(a, b)
//   (a, 0): g = a, x = 1, y = 0
//   (0, b), (b, b), (-b, b) (b != 0): g = b, x = 0, y = 1
//   otherwise: 2 |x| <= |b|, 2 |y| <= |a|
// S: signed integer
template <class S> S gojo(S a, S b, S &x, S &y) {
  if (b != 0) {
    const S g = gojo(b, a % b, y, x);
    y -= (a / b) * x;
    return g;
  } else {
    x = 1;
    y = 0;
    return a;
  }
}

// x == bs[i]  (mod ms[i])
// S: signed integer
template <class S>
// pair<S, S> modSystem(const vector<S> &ms, const vector<S> &bs) {
pair<S, S> modSystem(S m0, S b0, S m1, S b1) {
  // const int len = ms.size();
  // assert(static_cast<size_t>(len) == bs.size());
  // S m0 = 1, b0 = 0;
  // for (int i = 0; i < len; ++i) {
    // assert(ms[i] >= 1);
    // S m1 = ms[i], b1 = bs[i];
    if ((b1 %= m1) < 0) b1 += m1;
    if (m0 < m1) {
      swap(m0, m1);
      swap(b0, b1);
    }
    // to avoid overflow
    if (m0 % m1 == 0) {
      if (b0 % m1 != b1) return make_pair(0, 0);
      return make_pair(m0, b0);// continue;
    }
    S z0, z1;
    const S g = gojo(m0, m1, z0, z1);
    b1 -= b0;
    if (b1 % g != 0) return make_pair(0, 0);
    (b1 /= g) %= m1;
    m1 /= g;
    b0 += m0 * ((z0 * b1) % m1);
    m0 *= m1;
    if (b0 < 0) b0 += m0;
  // }
  return make_pair(m0, b0);
}


Int TEN[20];
Int N, C;

Int P;
int len;
Int M[20], B[20];

// 1 <= p <= P
// p == b  (mod m)
Int dfs(int i, Int m, Int b) {
  chmin(m, P + 1);
  Int ret = 0;
  if (b <= P) {
    ret += (P - b) / m + 1;
    if (b == 0) --ret;
    for (int j = i + 1; j < len; ++j) {
      // const auto res = modSystem<Int>({m, M[j]}, {b, B[j]});
      const auto res = modSystem<Int>(m, b, M[j], B[j]);
      if (res.first) {
        ret -= dfs(j, res.first, res.second);
      }
    }
  }
  return ret;
}

int main() {
  TEN[0] = 1;
  for (int e = 1; e <= 14; ++e) TEN[e] = TEN[e - 1] * 10;
  
  for (; ~scanf("%lld%lld", &N, &C); ) {
    Int ans = 0;
    for (Int k = 1, ten = 10; k <= 7; ++k, ten *= 10) {
      const Int q = N / ten;
      const Int r = N % ten;
      if (q >= 1) {
        for (Int s = (k == 1) ? 0 : TEN[k - 1]; s < TEN[k]; ++s) {
          P = (r >= s) ? q : (q - 1);
          len = 1;
          M[0] = s + C;
          B[0] = 0;
          for (Int j = k - 1; j >= 1; --j) {
            // a p + b == 0  (mod m)
            Int a = TEN[k - j];
            Int b = s / TEN[j];
            Int m = s % TEN[j] + C;
            Int x, y;
            const Int g = gojo(a, m, x, y);
            if (b % g == 0) {
              M[len] = m/g;
              B[len] = -((b/g) * x % (m/g));
              ++len;
            }
          }
          const Int res = dfs(0, M[0], B[0]);
/*
if(N<1000){
 cerr<<"k = "<<k<<", s = "<<s<<", res = "<<res<<endl;
 cerr<<"  M = ";pv(M,M+len);
 cerr<<"  B = ";pv(B,B+len);
}
*/
          ans += res;
        }
      }
    }
    printf("%lld\n", ans);
  }
  return 0;
}