#include <bits/stdc++.h>

using i64 = long long;

template<class T>
T qmi(T a, i64 b) {
    T res = 1;
    for (; b; b /= 2, a *= a) {
        if (b % 2) {
            res *= a;
        }
    }
    return res;
}

i64 mul(i64 a, i64 b, i64 p) {
    i64 res = a * b - i64(1.L * a * b / p) * p;
    res %= p;
    if (res < 0) {
        res += p;
    }
    return res;
}

template<int P>
struct modint {
    int x;
    constexpr modint() : x{} {}
    constexpr modint(i64 x) : x{norm(x % getmod())} {}

    static int mod;
    constexpr static int getmod() {
        if (P > 0) {
            return P;
        } else {
            return mod;
        }
    }
    constexpr static void setmod(int m) {
        mod = m;
    }
    constexpr int norm(int x) const {
        if (x < 0) {
            x += getmod();
        }
        if (x >= getmod()) {
            x -= getmod();
        }
        return x;
    }
    constexpr int val() const {
        return x;
    }
    explicit constexpr operator int() const {
        return x;
    }
    constexpr modint operator-() const {
        modint res;
        res.x = norm(getmod() - x);
        return res;
    }
    constexpr modint inv() const {
        assert(x != 0);
        return qmi(*this, getmod() - 2);
    }
    constexpr modint &operator*= (modint v) & {
        x = 1LL * x * v.x % getmod();
        return *this;
    }
    constexpr modint &operator+= (modint v) & {
        x = norm(x + v.x);
        return *this;
    }
    constexpr modint &operator-= (modint v) & {
        x = norm(x - v.x);
        return *this;
    }
    constexpr modint &operator/= (modint v) & {
        return *this *= v.inv();
    }
    friend constexpr modint operator- (modint a, modint b) {
        modint res = a;
        res -= b;
        return res;
    }
    friend constexpr modint operator+ (modint a, modint b) {
        modint res = a;
        res += b;
        return res;
    }
    friend constexpr modint operator* (modint a, modint b) {
        modint res = a;
        res *= b;
        return res;
    }
    friend constexpr modint operator/ (modint a, modint b) {
        modint res = a;
        res /= b;
        return res;
    }
    friend constexpr std::istream &operator>> (std::istream& is, modint& a) {
        i64 v;
        is >> v;
        a = modint(v);
        return is;
    }
    friend constexpr std::ostream &operator<< (std::ostream& os, const modint& a) {
        return os << a.val();
    }
    friend constexpr bool operator== (modint a, modint b) {
        return a.val() == b.val();
    }
    friend constexpr bool operator!= (modint a, modint b) {
        return a.val() != b.val();
    }
};

constexpr int P = 998244353;
using mint = modint<P>;

constexpr int B = 62;

int get(char c) {
    if (c >= 'A' && c <= 'Z') {
        return c - 'A';
    }
    if (c >= 'a' && c <= 'z') {
        return c - 'a' + 26;
    }
    return c - '0' + 52;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    std::string s;
    std::cin >> s;
    int n = s.size();

    std::vector<int> cnt(B);
    std::vector f(n, std::vector<mint>(B));
    std::vector s0(B, std::vector<mint>(B));
    std::vector s1(B, std::vector<mint>(B));
    for (int i = n - 1; i >= 0; i -- ) {
        int x = get(s[i]);
        for (int j = 0; j < B; j ++ ) {
            f[i][j] += s0[x][j];
        }
        for (int j = 0; j < B; j ++ ) {
            s0[j][x] += s1[j][x];
        }
        for (int j = 0; j < B; j ++ ) {
            s1[x][j] += cnt[j];
        }
        cnt[x] ++ ;
    }

    mint ans = 0;
    std::vector<int> sum(B);
    for (int i = 0; i < n; i ++ ) {
        int x = get(s[i]);

        mint c = 1LL * i * (i - 1) / 2;
        for (int j = 0; j < B; j ++ ) {
            c -= 1LL * sum[j] * (sum[j] - 1) / 2;
        }

        for (int j = 0; j < B; j ++ ) {
            if (x == j) {
                continue;
            }
            mint nc = c;
            nc += 1LL * sum[j] * (sum[j] - 1);
            nc -= 1LL * sum[j] * (i - 1);
            nc -= 1LL * sum[x] * (i - 1);
            nc += 1LL * sum[x] * (sum[x] - 1);
            nc += 1LL * sum[j] * sum[x];
            ans += nc * f[i][j];
        }

        sum[x] ++ ;
    }

    std::cout << ans << "\n";

    return 0;
}