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

#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
#define trav(a, x) for (auto& a : x)
#define per(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define sz(x) int(x.size())
#define all(x) x.begin(), x.end()

template <class T> using vc = vector<T>;
template <class T> using vvc = vc<vc<T>>;

using ll = int64_t;
using vi = vc<int>;
using pii = pair<int, int>;

struct H {
	using ull = uint64_t;
	ull x;
	H(ull x_ = 0) : x(x_) {}
#define OP(O,A,B) H operator O(H o) { ull r = x; asm \
	(A "addq %%rdx, %0\n adcq $0,%0" : "+a"(r) : B); return r; }
	OP(+,,"d"(o.x)) OP(*,"mul %1\n", "r"(o.x) : "rdx")
	H operator - (H o) { return *this + H(~o.x); }
	explicit operator ull() const { return x + !~x; }
	bool operator == (H o) const { return ull(*this) == ull(o); }
	bool operator < (H o) const { return ull(*this) < ull(o); }
};

mt19937_64 mt(chrono::steady_clock::now().time_since_epoch().count());

H rand_base() {
	using ull = uint64_t;
	static const ull m(-1);
	auto a = uniform_int_distribution<ull>(0, m-1)(mt);
	return H(a);
}

// Author: maroonrk (modified)
// https://codeforces.com/contest/1738/submission/174140231
template<class S>
struct eertree{
	struct N{
		int suf,ser,l,r;
		int len(){return r-l;}
		//map<int,int> ch;
		array<int,26> ch;
	};
	vc<N> x;
	int dist(int v){
		if(x[v].suf<=0)return -1;
		return x[v].len()-x[x[v].suf].len();
	}
	int c;
	S s;
	eertree(){
		x.push_back({-1,-1,1,0,{}});
		x.push_back({0,-1,0,0,{}});
		c=1;
	}
	void reserve(int n) {
		s.reserve(n+5);
		x.reserve(n+5);
	}
	bool chk(int v,int i){
		int l=i-x[v].len();
		return l>0&&s[l-1]==s[i];
	}
	template<class t>
	int extend(t z){
		int i=sz(s);
		s.push_back(z);
		
		while(!chk(c,i))c=x[c].suf;
		if(x[c].ch[s[i]]==0){
			int d=x[c].suf;
			if(d!=-1)while(!chk(d,i))d=x[d].suf;
			int e=d==-1?1:x[d].ch[s[i]];
			int f=x[c].ch[s[i]]=sz(x);
			x.push_back({e,e,i-x[c].len()-1,i+1,{}});
			if(dist(f)==dist(e))
				x[f].ser=x[e].ser;
		}
		return c=x[c].ch[s[i]];
	}
	N& operator[](int i){
		return x[i];
	}
};

struct custom_hash {
	static const uint64_t c = ll(4e18 * acos(0)) + 71;
	const ll z = mt();
	ll operator () (ll x) const { return __builtin_bswap64((x ^ z) * c); }
};
template <class K>
using hash_set = __gnu_pbds::gp_hash_table<K, __gnu_pbds::null_type, custom_hash>;

int main() {
	ios_base::sync_with_stdio(false), cin.tie(nullptr);
	cout << fixed << setprecision(20);

	int N;
	cin >> N;

	using ull = uint64_t;
	const H base = rand_base();
	vector<H> pows = {1};
	vector<hash_set<ull>> cnds;

	for (int i = 0; i < N; i++) {
		string t;
		cin >> t;
		int L = int(t.size());

		eertree<vector<int>> et;
		et.reserve(L);

		while (int(pows.size()) < L+1) {
			pows.push_back(pows.back() * base);
		}
		while (int(cnds.size()) < L+1) {
			cnds.emplace_back();
		}

		vector<H> pref(L+1);
		vector<bool> seen(L+3);
		for (int j = 0; j < L; j++) {
			int x = int(t[j] - 'a');
			pref[j+1] = pref[j] * base + H(x);

			int cur = et.extend(x);
			if (!seen[cur]) {
				seen[cur] = true;
				int l = et[cur].l;
				int r = et[cur].r;
				assert(r == j+1);
				int len = r-l;
				auto v = pref[r] - pref[l] * pows[len];
				cnds[len].insert(ull(v));
			}
		}
	}

	ll ans = 0;
	const int max_len = int(cnds.size())-1;
	for (int len = 1; len <= max_len; len++) {
		for (const auto& v : cnds[len]) {
			int rep = 1;
			int cur_len = len;
			H cur = v;
			while (true) {
				cur_len += len;
				if (cur_len > max_len) break;
				cur = cur * pows[len] + v;
				auto z = cnds[cur_len].find(ull(cur));
				if (z == cnds[cur_len].end()) {
					break;
				}
				cnds[cur_len].erase(*z);
				rep++;
			}
			ans += ll(rep) * rep;
		}
	}
	cout << ans << '\n';
}