#include <iostream>
#include <vector>

// sortuje rosnąco ciąg liczb od podanej pozycji do końca
void sortuj(std::vector<short int>& cyfry, const short int pozycja = 0) {
    auto n{ cyfry.size() };
    for (short int i = 0; i < n - pozycja - 1; ++i) {
        for (short int j = pozycja; j < n - i - 1; ++j) {
            if (cyfry[j] > cyfry[j + 1]) {
                std::swap(cyfry[j], cyfry[j + 1]);
            }
        }
    }
}

// generuje ciąg cyfr ułożonych rosnąco z podanej liczby
std::vector<short int> wygeneruj_pierwszy_ciag(unsigned long long liczba) {
    std::vector<short int> wynik{};
    while (liczba > 0) {
        wynik.push_back(liczba % 10);
        liczba /= 10;
    }
    sortuj(wynik);
    return wynik;
}

// przekształca ciąg cyfr na liczbę
unsigned long long wygeneruj_liczbe_z_ciagu(const std::vector<short int>& ciag) {
    unsigned long long wynik{};
    const auto size{ ciag.size() };
    for (auto i{ 0 }; i < size; ++i) {
        wynik = wynik * 10 + ciag[i];
    }
    return wynik;
}

// znajduję pozycję ostatniej cyfry mniejszej od następującej po niej lub -1 jeśli takiej nie ma
short int znajdz_najmniejsza(const std::vector<short int>& ciag) {
    for (auto i{ static_cast<short int>(ciag.size() - 2) }; i >= 0; --i) {
        if (ciag[i] < ciag[i + 1]) {
            return i;
        }
    }
    return -1;
}

// znajduję pozycję najmniejszej z cyfr większych od ciag[k] stojących po k
short int znajdz_nastepna_wieksza(const std::vector<short int>& ciag, const short int& k) {
    const auto size{ ciag.size() };
    auto pozycja{ k + 1 };
    for (auto i{ k + 2 }; i < size; ++i) {
        if (ciag[i] > ciag[k] && ciag[i] < ciag[pozycja]) {
            pozycja = i;
        }
    }
    return static_cast<short int>(pozycja);
}

bool wygeneruj_nastepny_ciag(std::vector<short int>& ciag) {
    const auto k{ znajdz_najmniejsza(ciag) };
    if (k == -1) {
        return false;
    }
    const auto n{ znajdz_nastepna_wieksza(ciag, k) };
    std::swap(ciag[n], ciag[k]);
    sortuj(ciag, k + 1);
    return true;
}

// sprawdza ile jest liczb złożonych z cyfr liczby a podzielnych przez b
int ile_liczb(const unsigned long long& a, const int& b) {
    int wynik{};
    auto ciag{ wygeneruj_pierwszy_ciag(a) };
    do {
        if (wygeneruj_liczbe_z_ciagu(ciag) % b == 0) {
            ++wynik;
        }
    } while (wygeneruj_nastepny_ciag(ciag));
    return wynik;
}

int main() {
    unsigned long long a;
    int b;
    std::cout << "Podaj dwie liczby calkowite (oddzielone spacja): ";
    std::cin >> a >> b;
    std::cout << ile_liczb(a, b) << std::endl;

    return 0;
}