#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using u128 = unsigned __int128;

std::vector<int> Z(std::string s) {
    int n = s.size();
    std::vector<int> z(n + 1);
    z[0] = n;
    for (int i = 1, j = 1; i < n; i++) {
        z[i] = std::max(0, std::min(j + z[j] - i, z[i - j]));
        while (i + z[i] < n && s[z[i]] == s[i + z[i]]) {
            z[i]++;
        }
        if (i + z[i] > j + z[j]) {
            j = i;
        }
    }
    return z;
}

constexpr int inf = 1E9;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n;
    std::cin >> n;
    
    std::vector<std::string> s(n);
    for (int i = 0; i < n; i++) {
        std::cin >> s[i];
    }
    
    std::vector<std::vector<int>> z(n);
    for (int i = 0; i < n; i++) {
        z[i] = Z(s[i]);
    }
    
    std::vector<int> p(n);
    std::iota(p.begin(), p.end(), 0);
    std::sort(p.begin(), p.end(),
        [&](int i, int j) {
            int l = 0;
            auto &a = s[i];
            auto &b = s[j];
            while (l < a.size() && l < b.size() && a[l] == b[l]) {
                l++;
            }
            if (l < a.size() && l < b.size()) {
                return a[l] < b[l];
            }
            if (l == a.size()) {
                l = z[j][l];
                if (a.size() + l < b.size()) {
                    return b[l] < b[a.size() + l];
                }
                return b.substr(b.size() - a.size()) < a;
            } else {
                l = z[i][l];
                if (b.size() + l < a.size()) {
                    return a[b.size() + l] < a[l];
                }
                return b < a.substr(a.size() - b.size());
            }
        });
    
    std::vector<int> lc(n);
    for (int i = 1; i < n; i++) {
        auto a = s[p[i - 1]] + s[p[i]];
        auto b = s[p[i]] + s[p[i - 1]];
        if (a == b) {
            lc[i] = inf;
        } else {
            int l = 0;
            while (a[l] == b[l]) {
                l++;
            }
            lc[i] = l;
        }
    }
    
    i64 ans = 0;
    auto work = [&](auto &&self, int l, int r) -> void {
        if (r - l <= 1) {
            return;
        }
        int x = *std::min_element(lc.begin() + l + 1, lc.begin() + r);
        if (x == inf) {
            return;
        }
        i64 prod = 1;
        int cnt = 0;
        int lst = l;
        for (int i = l + 1; i <= r; i++) {
            if (i == r || lc[i] == x) {
                self(self, lst, i);
                prod *= (i - lst);
                lst = i;
                cnt++;
            }
        }
        if (cnt == 3) {
            ans += prod;
        }
    };
    work(work, 0, n);
    
    std::cout << ans << "\n";
    
    return 0;
}