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

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

struct DSU {
	vector<int> P, S;
	DSU(int n) {
		P.resize(n+1);
		S.resize(n+1, 1);
		for (int i = 1; i <= n; i++) P[i] = i;
	}
	
	int find(int x) {
		if (x == P[x]) return x;
		return P[x] = find(P[x]);
	}
	
	bool merge(int a, int b) {
		a = find(a); b = find(b);
		if (a == b) return 0;
		if (S[a] < S[b]) swap(a, b);
		
		S[a] += S[b];
		P[b] = a;
		return 1;
	}
	
	int same(int a, int b) {
		return find(a) == find(b);
	}
};

struct SuffixArray {
	vi sa, lcp;
	SuffixArray(string& s, int lim=256) { // or basic_string<int>
		int n = sz(s) + 1, k = 0, a, b;
		vi x(all(s)+1), y(n), ws(max(n, lim)), rank(n);
		sa = lcp = y, iota(all(sa), 0);
		for (int j = 0, p = 0; p < n; j = max(1, j * 2), lim = p) {
			p = j, iota(all(y), n - j);
			rep(i,0,n) if (sa[i] >= j) y[p++] = sa[i] - j;
			fill(all(ws), 0);
			rep(i,0,n) ws[x[i]]++;
			rep(i,1,lim) ws[i] += ws[i - 1];
			for (int i = n; i--;) sa[--ws[x[y[i]]]] = y[i];
			swap(x, y), p = 1, x[sa[0]] = 0;
			rep(i,1,n) a = sa[i - 1], b = sa[i], x[b] =
				(y[a] == y[b] && y[a + j] == y[b + j]) ? p - 1 : p++;
		}
		rep(i,1,n) rank[sa[i]] = i;
		for (int i = 0, j; i < n - 1; lcp[rank[i++]] = k)
			for (k && k--, j = sa[rank[i] - 1];
					s[i + k] == s[j + k]; k++);
	}
};

struct H {
	typedef uint64_t ull;
	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 + ~o.x; }
	ull get() const { return x + !~x; }
	bool operator==(H o) const { return get() == o.get(); }
	bool operator<(H o) const { return get() < o.get(); }
};
static const H C = (ll)1e11+3; // (order ~ 3e9; random also ok)

struct HashInterval {
	vector<H> ha, pw;
	HashInterval(string& str) : ha(sz(str)+1), pw(ha) {
		pw[0] = 1;
		rep(i,0,sz(str))
			ha[i+1] = ha[i] * C + str[i],
			pw[i+1] = pw[i] * C;
	}
	H hashInterval(int a, int b) { // hash [a, b)
		return ha[b] - ha[a] * pw[b - a];
	}
};

H hashString(string& s){H h{}; for(char c:s) h=h*C+c;return h;}

vector<string> s;
vector<HashInterval> hs;

int lcp(int i1, int j1, int i2, int j2) {
	int lo = 0, hi = min(s[i1].size() - j1, s[i2].size() - j2);
	while (lo < hi) {
		int mid = (lo + hi + 1)/2;
		if (hs[i1].hashInterval(j1, j1+mid) == hs[i2].hashInterval(j2, j2+mid)) {
			lo = mid;
		} else {
			hi = mid - 1;
		}
	}
	return lo;
}

bool cmp(pair<int, int> p1, pair<int, int> p2) {
	auto [i1, j1] = p1;
	auto [i2, j2] = p2;

	int lc = lcp(i1, j1, i2, j2);
	char c1 = '0', c2 = '0';
	if (j1 + lc != s[i1].size()) {
		c1 = s[i1][j1 + lc];
	}
	if (j2 + lc != s[i2].size()) {
		c2 = s[i2][j2 + lc];
	}
	return c1 < c2;
}

signed main() {
	ios::sync_with_stdio(0); cin.tie(0);

	int n; cin >> n;
	s.resize(n);
	for (int i = 0; i < n; i++) {
		cin >> s[i];
		hs.push_back(HashInterval(s[i]));
	}

	vector<pair<int, int>> sa;
	
	// let's try something new
	string lg; vector<int> lens;
	for (int i = 0; i < n; i++) {
		lg += s[i]; lg += "#";
		if (lens.empty()) {
			lens.push_back(s[i].size() + 1);
		} else {
			lens.push_back(lens.back() + s[i].size() + 1);
		}
	}
	SuffixArray saf(lg);
	for (int i = 1; i < saf.sa.size(); i++) {
		int id = upper_bound(lens.begin(), lens.end(), saf.sa[i]) - lens.begin();
		int ii = id;
		int jj = (ii == 0 ? saf.sa[i] : (saf.sa[i] - lens[ii-1]));
		if (jj == s[ii].size()) continue;

		sa.emplace_back(ii, jj);
	}
	// done

	/*
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < s[i].size(); j++) {
			sa.emplace_back(i, j);
		}
	}
	sort(sa.begin(), sa.end(), cmp);
	*/

	vector<tuple<int, int, int>> ed;
	for (int i = 1; i < sa.size(); i++) {
		auto [i1, j1] = sa[i];
		auto [i2, j2] = sa[i-1];

		int w = lcp(i1, j1, i2, j2);
		ed.emplace_back(-w, i1, i2);
	}
	sort(ed.begin(), ed.end());

	DSU d(n);
	int ans = 0;
	for (auto [w, u, v]: ed) {
		if (d.merge(u, v)) {
			ans -= w;
		}
	}
	cout << ans << '\n';

	return 0;
}