#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef tuple<int, int, int> tii;

#define eb emplace_back
#define pb push_back
#define all(s) (s).begin(), (s).end()
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define per(i, a, b) for (int i = (a); i >= (b); --i)

inline int rd() {
    int x = 0;
    bool f = 0;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) f |= (c == '-');
    for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
    return f ? -x : x;
}

constexpr int N = 1000007;
constexpr int A = 26;

struct Palindromic_AutoMaton {
    vector<int> str; // the string formed by appending characters, indexing from 1
    int nxt[N][A], fail[N], len[N]; // A = the size of alphabet
    int num[N], r[N], last, tot;
    void clear() {
        len[fail[1] = 0] = 0; // node 0 is the even root with length 0
        len[fail[0] = 1] = -1; // node 1 is the odd root with length 1
        str.clear(); str.eb(-1); // -1 is a non-existent letter for boundary checking
        last = 0; tot = 1;
        num[0] = num[1] = 0;
        memset(nxt[0], 0, sizeof(nxt[0]));
        memset(nxt[1], 0, sizeof(nxt[1]));
    }
    Palindromic_AutoMaton(){clear();}
    int newnode(int _len) {
        len[++tot] = _len;
        r[tot] = _len;
        fail[tot] = num[tot] = 0;
        memset(nxt[tot], 0, sizeof(nxt[tot]));
        return tot;
    }
    int get_fail(int u) {
        int strlen = str.size() - 1;
        while (str[strlen - len[u] - 1] != str[strlen]) u = fail[u];
        return u;
    }
    void append(int ch) {
        str.emplace_back(ch);
        int fat = get_fail(last);
        if (!nxt[fat][ch]) {
            int cur = newnode(len[fat] + 2);
            fail[cur] = nxt[get_fail(fail[fat])][ch];
            if (len[cur] - len[fail[cur]] == r[fail[cur]]) {
                r[cur] = r[fail[cur]];
                num[cur] = num[fail[cur]] + 1;
            } else num[cur] = 1;
            nxt[fat][ch] = cur;
        }
        last = nxt[fat][ch];
    }
    ll calc() {
        ll ans = 0;
        rep(i, 2, tot) ans += num[i] * 2 - 1;
        return ans;
    }
} pam;

char s[N];

int main() {
    int n = rd();
    rep(i, 1, n) {
        scanf("%s", s + 1);
        pam.str.clear();
        pam.str.eb(-1); // -1 is a non-existent letter for boundary checking
        pam.last = 0;
        int len = strlen(s + 1);
        rep(j, 1, len) pam.append(s[j] - 'a');
    }
    printf("%lld\n", pam.calc());
    return 0;
}