Language: C++

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;
typedef tuple<unsigned, unsigned, unsigned> T;

template<unsigned mod>
struct RollingHash {
    vector<unsigned> hashed, power;

    inline unsigned mul(unsigned a, unsigned b) const {
        unsigned long long x = (unsigned long long) a * b;
        unsigned xh = (unsigned) (x >> 32), xl = (unsigned) x, d, m;
        asm("divl %4; \n\t" : "=a" (d), "=d" (m) : "d" (xh), "a" (xl), "r" (mod));
        return m;
    }

    RollingHash(const string &s, unsigned base = 10007) {
        int sz = (int) s.size();
        hashed.assign(sz + 1, 0);
        power.assign(sz + 1, 0);
        power[0] = 1;
        for (int i = 0; i < sz; i++) {
            power[i + 1] = mul(power[i], base);
            hashed[i + 1] = mul(hashed[i], base) + s[i];
            if (hashed[i + 1] >= mod) hashed[i + 1] -= mod;
        }
    }

    unsigned get(int l, int r) const {
        unsigned ret = hashed[r] + mod - mul(hashed[l], power[r - l]);
        if (ret >= mod) ret -= mod;
        return ret;
    }

    unsigned connect(unsigned h1, int h2, int h2len) const {
        unsigned ret = mul(h1, power[h2len]) + h2;
        if (ret >= mod) ret -= mod;
        return ret;
    }

    int LCP(const RollingHash<mod> &b, int l1, int r1, int l2, int r2) {
        int len = min(r1 - l1, r2 - l2);
        int low = -1, high = len + 1;
        while (high - low > 1) {
            int mid = (low + high) / 2;
            if (get(l1, l1 + mid) == b.get(l2, l2 + mid)) low = mid;
            else high = mid;
        }
        return (low);
    }
};

using RH1 = RollingHash<1000000007>;
using RH2 = RollingHash<998244353>;
using RH3 = RollingHash<10007>;

bool comp(const string &lh, const string &rh) {
    return lh.length() > rh.length();
}

int main() {
    int n;
    cin >> n;
    vector<string> s(n);
    for (int i = 0; i < n; i++)cin >> s[i];
    sort(s.begin(), s.end(), comp);

    long long ret = 0;
    unordered_map<T, vector<int>> ma;
    for (int i = 0; i < n; i++) {
        RH1 x(s[i]);
        RH2 y(s[i]);
        RH3 z(s[i]);

        T suffix = {x.get(1, s[i].size()), y.get(1, s[i].size()), z.get(1, s[i].size())};
        if (ma.find(suffix) != ma.end()) {
            ret += ma[suffix][s[i][0] - 'a'];
        }

        vector<bool> found(26);
        for (int j = 0; j <= s[i].size(); j++) {
            if (j > 0) {
                T now = {x.get(j, s[i].size()), y.get(j, s[i].size()), z.get(j, s[i].size())};
                if (ma.find(now) == ma.end())ma[now] = vector<int>(26);
                for (int k = 0; k < 26; k++) {
                    ma[now][k] += found[k] ? 1 : 0;
                }
            }
            if (j < s[i].size())found[s[i][j] - 'a'] = true;
        }
    }

    cout << ret << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:72:5: error: 'unordered_map' was not declared in this scope
   72 |     unordered_map<T, vector<int>> ma;
      |     ^~~~~~~~~~~~~
a.cc:5:1: note: 'std::unordered_map' is defined in header '<unordered_map>'; this is probably fixable by adding '#include <unordered_map>'
    4 | #include <algorithm>
  +++ |+#include <unordered_map>
    5 | 
a.cc:72:20: error: expected primary-expression before ',' token
   72 |     unordered_map<T, vector<int>> ma;
      |                    ^
a.cc:72:32: error: expected primary-expression before '>' token
   72 |     unordered_map<T, vector<int>> ma;
      |                                ^~
a.cc:72:35: error: 'ma' was not declared in this scope
   72 |     unordered_map<T, vector<int>> ma;
      |                                   ^~