#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/hash_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

typedef long long ll;
typedef __int128_t i128;

const int MAX_M = 1000000 + 5;
const int Base = 5;
const ll P = 998244353998244347ll;
const ll BS = 1e13;

inline ll add(ll a, ll b) {return a + b < P ? a + b : a + b - P;}
inline ll mul(ll a, ll b) {return (i128)(a) * b % P;}

ll pw[MAX_M], pw2[MAX_M], ipw[MAX_M];

ll qpow(ll n) {return mul(pw2[n / (MAX_M - 1)], pw[n % (MAX_M - 1)]);}

int N, cnt[MAX_M], tot;
string str[MAX_M];
struct TrieNode{
    int sz, sum, son[3];
}node[MAX_M];
struct Hash{
    int n;
    ll ha[MAX_M], temp[MAX_M];
    
    void init(const string &s) {
        n = s.size();
        for (int i = 1; i <= n; i ++) {
            ha[i] = (ha[i - 1] * Base + s[i - 1]) % P;
            temp[i] = mul(ha[i], ipw[i]);
        }
    }
    
    ll query(int pref, ll len) {
        ll k = len / pref, r = len % pref;
        // pw[r] * (k times pref) + ha[r]
        // k times pref : ha[pref] * (pw[k*pref] - 1) * ipw[pref]
        return add(mul(mul(temp[pref], add(qpow(k * pref), P - 1)), pw[r]), ha[r]);
    }
}ha;
gp_hash_table <ll, int> status;
ll ans;

void ins(const string &s) {
    int u = 0, len = 0;
    for (auto x : s) {
        int y = x != 1, z = 3 - x - y;
        ans += 1ll * node[node[u].son[y]].sum * node[node[u].son[z]].sum;
        status[len + y * BS] = node[node[u].son[y]].sum;
        status[len + z * BS] = node[node[u].son[z]].sum;
        int &v = node[u].son[x]; v = v ? v : ++ tot;
        cnt[++ len] = node[v].sz; node[u = v].sum ++;
    }
    node[u].sz ++;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    
    static int Map[128];
    Map['K'] = 0;
    Map['N'] = 1;
    Map['P'] = 2;
    pw[0] = 1; pw2[0] = 1;
    auto power = [&](ll a, ll n) -> ll {
        ll ans = 1;
        while (n) {
            if (n & 1) ans = mul(ans, a);
            a = mul(a, a); n >>= 1;
        }
        return ans;
    };
    for (int i = 1; i < MAX_M; i ++) {
        pw[i] = pw[i - 1] * Base % P;
        ipw[i] = power(add(pw[i], P - 1), P - 2);
    }
    for (int i = 1; i < MAX_M; i ++) {
        pw2[i] = mul(pw2[i - 1], pw[MAX_M - 1]);
    }
    
    cin >> N;
    for (int i = 1; i <= N; i ++) {
        cin >> str[i];
        for (auto &x : str[i]) x = Map[x];
    }
    sort(str + 1, str + N + 1, [&](const string &i, const string &j) -> bool {return i.size() < j.size();});
    for (int i = 1; i <= N; i ++) {
        status.clear();
        ins(str[i]);
        ha.init(str[i]);
        for (int j = 1; j < str[i].size(); j ++) {
            ll l = j + 1, r = 1ll * j * str[i].size() / __gcd(j, (int)str[i].size()) + 1;
            while (l < r) {
                ll mid = l + r >> 1;
                if (ha.query(j, mid) == ha.query(str[i].size(), mid)) l = mid + 1;
                else r = mid;
            }
            l --;
            if (l >= 1ll * j * str[i].size()) continue;
            int x = str[i][l % str[i].size()], y = str[i][l % j], z = 3 - x - y;
            ans += 1ll * status[l + z * BS] * cnt[j];
            status[l + y * BS] += cnt[j];
        }
    }
    cout << ans << '\n';
    
    return 0;
}