#include <bits/stdc++.h>

using i64 = long long;

constexpr int N = 2E6 + 2;

int trie[N][26];
int id[N];
int fail[N], lst[N], len[N];
int tot = 1;

std::vector<int> adj[N];
int in[N], out[N];
int cur = 0;
bool flag[N];
int col[N];

void dfs(int x) {
    in[x] = cur++;
    for (auto y : adj[x]) {
        dfs(y);
    }
    out[x] = cur;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    std::memset(id, -1, sizeof(id));
    std::memset(col, -1, sizeof(col));
    std::fill(trie[0], trie[0] + 26, 1);
    len[0] = -1;
    
    int n;
    std::cin >> n;
    
    std::vector<std::string> s(n);
    for (int i = 0; i < n; i++) {
        std::cin >> s[i];
        int p = 1;
        for (auto c : s[i]) {
            int x = c - 'a';
            if (!trie[p][x]) {
                trie[p][x] = ++tot;
                len[tot] = len[p] + 1;
            }
            p = trie[p][x];
        }
        id[p] = i;
    }
    
    std::queue<int> q;
    q.push(1);
    
    while (!q.empty()) {
        int x = q.front();
        q.pop();
        lst[x] = id[x] == -1 ? lst[fail[x]] : x;
        
        for (int i = 0; i < 26; i++) {
            if (trie[x][i]) {
                fail[trie[x][i]] = trie[fail[x]][i];
                q.push(trie[x][i]);
            } else {
                trie[x][i] = trie[fail[x]][i];
            }
        }
    }
    
    for (int i = 2; i <= tot; i++) {
        adj[fail[i]].push_back(i);
    }
    dfs(1);
    
    int ans = 0;
    
    for (auto s : s) {
        int m = s.size();
        int p = 1;
        std::vector<int> a;
        for (auto c : s) {
            p = trie[p][c - 'a'];
            int q = lst[p];
            if (len[p] == s.size()) {
                q = lst[fail[q]];
            }
            if (q) {
                a.push_back(q);
            }
            q = lst[fail[q]];
            if (q) {
                a.push_back(q);
                flag[q] = true;
            }
        }
        std::sort(a.begin(), a.end(),
            [&](int i, int j) {
                return in[i] < in[j];
            });
        a.erase(std::unique(a.begin(), a.end()), a.end());
        std::vector<int> stk;
        std::vector<int> b;
        for (auto x : a) {
            while (!stk.empty() && in[x] >= out[stk.back()]) {
                b.push_back(stk.back());
                stk.pop_back();
            }
            if (flag[x]) {
                stk.clear();
            }
            stk.push_back(x);
        }
        b.insert(b.end(), stk.begin(), stk.end());
        for (auto x : a) {
            flag[x] = false;
        }
        a = std::move(b);
        for (auto x : a) {
            flag[x] = true;
        }
        std::vector<std::array<int, 3>> seg;
        p = 1;
        for (auto c : s) {
            p = trie[p][c - 'a'];
            int R = len[p];
            int q = lst[p];
            if (len[p] == s.size()) {
                q = lst[fail[q]];
            }
            if (flag[q]) {
                seg.push_back({R - len[q], R, q});
            }
            q = lst[fail[q]];
            if (flag[q]) {
                seg.push_back({R - len[q], R, q});
            }
        }
        std::sort(seg.begin(), seg.end(),
            [&](auto a, auto b) {
                if (a[0] != b[0]) {
                    return a[0] < b[0];
                } else {
                    return a[1] > b[1];
                }
            });
        std::array<int, 2> mx{-1, -1}, c{-1, -1};
        for (auto [l, r, x] : seg) {
            if (mx[1] >= r) {
                flag[x] = false;
            } else if (mx[0] >= r && flag[x]) {
                if (col[x] == -1) {
                    col[x] = c[0];
                } else if (col[x] != c[0]) {
                    flag[x] = false;
                }
            }
            if (r > mx[0]) {
                if (c[0] != x) {
                    mx[1] = mx[0];
                    c[1] = c[0];
                }
                mx[0] = r;
                c[0] = x;
            } else if (r > mx[1] && c[0] != x) {
                mx[1] = r;
                c[1] = x;
            }
        }
        for (auto x : a) {
            if (flag[x] && col[x] != -1) {
                ans++;
            }
            col[x] = -1;
            flag[x] = false;
        }
    }
    
    std::cout << ans << "\n";
    
    return 0;
}