function countGoodSubsequences(word) {
    const MOD = BigInt(1e9 + 7);

    // Count the frequency of each character in the word
    const freqMap = {};
    for (const char of word) {
        freqMap[char] = (freqMap[char] || 0) + 1;
    }

    const frequencies = Object.values(freqMap).map(BigInt);
    const maxFrequency = frequencies.reduce((max, freq) => freq > max ? freq : max, 0n);

    // Precompute factorials and inverse factorials modulo MOD
    const factorial = [1n];
    for (let i = 1n; i <= maxFrequency; i++) {
        factorial.push((factorial[factorial.length - 1] * i) % MOD);
    }

    const invFactorial = factorial.map(f => modInverse(f, MOD));

    let totalGoodSubsequences = 0n;

    // Calculate good subsequences for each possible frequency
    for (let f = 1n; f <= maxFrequency; f++) {
        let totalWays = 1n;
        let hasValidChar = false;

        for (const freq of frequencies) {
            if (freq >= f) {
                const combinations = nCk(freq, f, factorial, invFactorial, MOD);
                totalWays = (totalWays * (1n + combinations)) % MOD;
                hasValidChar = true;
            }
        }

        if (hasValidChar) {
            totalWays = (totalWays - 1n + MOD) % MOD; // Exclude the empty subsequence
            totalGoodSubsequences = (totalGoodSubsequences + totalWays) % MOD;
        }
    }

    return Number(totalGoodSubsequences);

    // Helper function to compute nCk modulo MOD
    function nCk(n, k, factorial, invFactorial, MOD) {
        return (((factorial[Number(n)] * invFactorial[Number(k)]) % MOD) * invFactorial[Number(n - k)]) % MOD;
    }

    // Modular inverse using Fermat's little theorem
    function modInverse(a, MOD) {
        return modPow(a, MOD - 2n, MOD);
    }

    // Modular exponentiation
    function modPow(base, exponent, MOD) {
        let result = 1n;
        base = base % MOD;
        while (exponent > 0n) {
            if (exponent % 2n === 1n) {
                result = (result * base) % MOD;
            }
            base = (base * base) % MOD;
            exponent = exponent / 2n;
        }
        return result;
    }
}