#include <bits/stdc++.h>
using namespace std;

// Compute nCk using 64‑bit arithmetic (fits for the given constraints).
static unsigned long long nCk(int n, int k){
    if(k<0||k>n) return 0ULL;
    if(k>n-k) k=n-k;
    unsigned long long res=1ULL;
    for(int i=1;i<=k;++i){
        res = res * (n - k + i) / i;
    }
    return res;
}

long long countSequences(const string &s, int k){
    vector<bool> seen(256,false);
    int distinct=0;
    for(char c: s){
        unsigned char uc=c;
        if(!seen[uc]){ seen[uc]=true; ++distinct; }
    }
    return (long long)nCk(distinct,k);
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    string s; int k;
    if(!(cin>>s>>k)) return 0;
    cout<<countSequences(s,k);
    return 0;
}

import java.io.*;
import java.util.*;

public class Main {
    // Compute nCk using long (assumes result fits in 64‑bit).
    private static long nCk(int n, int k) {
        if (k < 0 || k > n) return 0L;
        if (k > n - k) k = n - k;
        long res = 1L;
        for (int i = 1; i <= k; ++i) {
            res = res * (n - k + i) / i;
        }
        return res;
    }

    static long countSequences(String s, int k) {
        boolean[] seen = new boolean[256];
        int distinct = 0;
        for (int i = 0; i < s.length(); ++i) {
            int idx = s.charAt(i) & 0xFF;
            if (!seen[idx]) {
                seen[idx] = true;
                ++distinct;
            }
        }
        return nCk(distinct, k);
    }

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        String s = st.nextToken();
        int k = Integer.parseInt(st.nextToken());
        System.out.println(countSequences(s, k));
    }
}

def count_sequences(s: str, k: int) -> int:
    """Return the number of distinct ingredient sequences of length k that can be formed from s.
    The answer is C(d, k) where d is the number of distinct characters in s.
    """
    distinct = len(set(s))
    if k < 0 or k > distinct:
        return 0
    # Compute binomial coefficient efficiently.
    k = min(k, distinct - k)
    res = 1
    for i in range(1, k + 1):
        res = res * (distinct - k + i) // i
    return res

if __name__ == "__main__":
    import sys
    data = sys.stdin.read().strip().split()
    if len(data) >= 2:
        s, k = data[0], int(data[1])
        print(count_sequences(s, k))

// Returns the number of distinct ingredient sequences of length k that can be formed from s.
function countSequences(s, k) {
    const seen = new Set();
    for (const ch of s) seen.add(ch);
    const distinct = seen.size;
    if (k < 0 || k > distinct) return 0n;
    // Compute binomial coefficient using BigInt to avoid overflow.
    let kk = Math.min(k, distinct - k);
    let res = 1n;
    for (let i = 1; i <= kk; ++i) {
        res = res * BigInt(distinct - kk + i) / BigInt(i);
    }
    return res;
}

// Driver
const fs = require('fs');
const input = fs.readFileSync(0, 'utf8').trim().split(/\s+/);
if (input.length >= 2) {
    const s = input[0];
    const k = Number(input[1]);
    console.log(countSequences(s, k).toString());
}