#include<bits/stdc++.h>

using namespace std;   

#define forn(i, n) for(int i = 0; i < int(n); i++)
#define fore(i, l, r) for(int i = int(l); i < int(r); i++)
#define x first
#define y second

int n;
vector<string> s;
const string al = "PKN";

bool read()
{
	if (!(cin >> n))
		return false;
	s.resize(n);
	forn(i, n){
		cin >> s[i];
		for (char &c : s[i]){
			c = al.find(c) + 'A';
		}
	}
	return true;
}

const int MOD1 = int(1e9) + 7;
const int MOD2 = int(1e9) + 9;
const int BASE = 345;

#ifdef _DEBUG
const int N = 5e3;
#else
const int N = 5e6;
#endif

int binpow(int a, int b, const int mod){
	int res = 1;
	while (b){
		if (b & 1)
			res = res * 1ll * a % mod;
		a = a * 1ll * a % mod;
		b >>= 1;
	}
	return res;
}

typedef pair<int, int> hs;

ostream& operator <<(ostream& out, const hs &a){
	return out << "(" << a.x << ", " << a.y << ")";
}

hs operator +(const hs &a, const hs &b){
	hs c(a.x + b.x, a.y + b.y);
	if (c.x >= MOD1) c.x -= MOD1;
	if (c.y >= MOD2) c.y -= MOD2;
	if (c.x < 0) c.x += MOD1;
	if (c.y < 0) c.y += MOD2;
	return c;
}

hs operator +(const hs &a, int x){
	hs c(a.x + x, a.y + x);
	if (c.x >= MOD1) c.x -= MOD1;
	if (c.y >= MOD2) c.y -= MOD2;
	if (c.x < 0) c.x += MOD1;
	if (c.y < 0) c.y += MOD2;
	return c;
}

hs operator *(const hs &a, const hs &b){
	return make_pair(a.x * 1ll * b.x % MOD1, a.y * 1ll * b.y % MOD2);
}

hs operator *(const hs &a, int x){
	return make_pair(a.x * 1ll * x % MOD1, a.y * 1ll * x % MOD2);
}

vector<hs> pw;
vector<vector<hs>> pr;

vector<hs> pw1;
vector<hs> rev;

hs get(int i, int l){
	int f = l / s[i].size();
	hs cur = pr[i].back() * pw1[s[i].size() * f] * rev[s[i].size()];
	return cur + pr[i][l % s[i].size()] * pw[s[i].size() * f];
}

bool eq(int i, int j, int l){
	return get(i, l) == get(j, l);
}

int lcp(int i, int j){
	int l = 1, r = N;
	int res = 0;
	while (l <= r){
		int m = (l + r) / 2;
		if (eq(i, j, m)){
			res = m;
			l = m + 1;
		}
		else{
			r = m - 1;
		}
	}
	return res;
}

vector<vector<pair<int, int>>> st;
vector<int> pws;

void build(const vector<int> &a){
	int n = a.size();
	int l = 32 - __builtin_clz(n);
	st.assign(l, vector<pair<int, int>>(n));
	forn(i, n) st[0][i].x = a[i], st[0][i].y = i;
	fore(j, 1, l) forn(i, n){
		st[j][i] = st[j - 1][i];
		if (i + (1 << (j - 1)) < n)
			st[j][i] = min(st[j][i], st[j - 1][i + (1 << (j - 1))]);
	}
	pws.resize(n + 1);
	pws[0] = pws[1] = 0;
	fore(i, 2, n + 1) pws[i] = pws[i / 2] + 1;
}

pair<int, int> getmin(int l, int r){
	if (l == r) return make_pair(N, -1);
	int len = pws[r - l];
	return min(st[len][l], st[len][r - (1 << len)]);
}

long long ans;

void calc(int l, int r, const vector<int> &ord){
	auto tmp = getmin(l, r - 1);
	int len = tmp.x;
	//cerr << l << " " << r << " " << len << endl;
	if (len == N) return;
	int m = tmp.y;
	vector<int> cnt(3);
	int prv = l;
	while (true){
		//cerr << prv << " " << m << endl;
		cnt[s[ord[prv]][len % s[ord[prv]].size()] - 'A'] += m - prv + 1;
		calc(prv, m + 1, ord);
		auto tmp = getmin(m + 1, r - 1);
		if (tmp.x != len){
			cnt[s[ord[m + 1]][len % s[ord[m + 1]].size()] - 'A'] += r - m - 1;
			calc(m + 1, r, ord);
			break;
		}
		prv = m + 1;
		m = tmp.y;
	}
	//cerr << "!";
	//cerr << l << " " << r << " " << "[";
	//for (int x : cnt) cerr << x << ", ";
	//cerr << "]" << endl;
	ans += cnt[0] * 1ll * cnt[1] * 1ll * cnt[2];
}

void solve()
{
	pw.resize(N);
	pw[0] = {1, 1};
	fore(i, 1, pw.size()) pw[i] = pw[i - 1] * BASE;
	pw1.resize(pw.size());
	forn(i, pw1.size()) pw1[i] = pw[i] + make_pair(-1, -1);
	rev.resize(pw.size());
	forn(i, rev.size()){
		rev[i].x = binpow(pw1[i].x, MOD1 - 2, MOD1);
		rev[i].y = binpow(pw1[i].y, MOD2 - 2, MOD2);
	}
	
	pr.resize(n);
	forn(i, n){
		pr[i].resize(s[i].size() + 1);
		pr[i][0] = {0, 0};
		forn(j, s[i].size())
			pr[i][j + 1] = pr[i][j] + pw[j] * int(s[i][j]);
	}
	
	//cerr << "!";
	vector<int> ord(n);
	iota(ord.begin(), ord.end(), 0);
	sort(ord.begin(), ord.end(), [](int i, int j){
		int l = lcp(i, j);
		if (l == N) return false;
		return s[i][l % s[i].size()] < s[j][l % s[j].size()];
	});
	//forn(i, n) cerr << s[ord[i]] << endl;
	
	vector<int> ls(n - 1);
	forn(i, n - 1) ls[i] = lcp(ord[i], ord[i + 1]);
	build(ls);
	
	ans = 0;
	calc(0, n, ord);
	cout << ans << '\n';
}

int main()
{
#ifdef _DEBUG
	freopen("input.txt", "r", stdin);
#endif
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	int t = 1;
	//cin >> t;
	forn(i, t)
	{
	 	read();
		solve();
	}
}