Description
兔子们在玩字符串的游戏。首先，它们拿出了一个字符串集合S，然后它们定义一个字
符串为“好”的，当且仅当它可以被分成非空的两段，其中每一段都是字符串集合S中某个字符串的前缀。
比如对于字符串集合{"abc","bca"}，字符串"abb"，"abab"是“好”的（"abb"="ab"+"b",abab="ab"+"ab"），而字符串“bc”不是“好”的。
兔子们想知道，一共有多少不同的“好”的字符串。

Input
第一行一个整数n，表示字符串集合中字符串的个数
接下来每行一个字符串

Output
一个整数，表示有多少不同的“好”的字符串

Sample Input
2
ab
ac

Sample Output
9

HINT
1<=n<=10000，每个字符串非空且长度不超过30，均为小写字母组成。

考虑总共组成的方案有前缀的平方种，然后考虑去重

我们规定最右边的划分方案一定是合法的。考虑图中绿色的串，红色串显然为其后缀，又因为红绿串都是字符集的前缀，红串又是满足条件的最长的一个，这就是“最长前缀匹配后缀”，也就是AC自动机的fail指针，因此每当存在一个蓝串结尾的前缀时，红串就会给绿串一个-1的贡献

于是问题就转化为：对于每一个串和它fail指针指向的串，求有多少个以两串相差部分为后缀的前缀。

AC自动机上，根到每个节点的路径都对应一个前缀。而以一个串为后缀的串的个数，就是它fail树上子树大小减一（本身不算）。于是暴枚每个串即可。注意一个串的fail指针如果指向根，则不存在一个串是它的后缀，那它一定是所在答案串中最靠右的划分方式，就不应减去了。

/*problem from Wolfycz*/
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define inf 0x7f7f7f7f
using namespace std;
typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
inline char gc(){
    static char buf[1000000],*p1=buf,*p2=buf;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,1000000,stdin),p1==p2)?EOF:*p1++;
}
inline int frd(){
    int x=0,f=1; char ch=gc();
    for (;ch<'0'||ch>'9';ch=gc())   if (ch=='-')    f=-1;
    for (;ch>='0'&&ch<='9';ch=gc()) x=(x<<3)+(x<<1)+ch-'0';
    return x*f;
}
inline int read(){
    int x=0,f=1; char ch=getchar();
    for (;ch<'0'||ch>'9';ch=getchar())  if (ch=='-')    f=-1;
    for (;ch>='0'&&ch<='9';ch=getchar())    x=(x<<3)+(x<<1)+ch-'0';
    return x*f;
}
inline void print(int x){
    if (x<0)    putchar('-');
    if (x>9)    print(x/10);
    putchar(x%10+'0');
}
const int N=1e4;
struct S1{
    int tot,root;
    struct node{
        int fa,fail,size,son[26];
        node(){
            fa=fail=size=0;
            memset(son,0,sizeof(son));
        }
    }tree[N*30+10];
    int h[N*30+10];
    S1(){tot=root=0;}
    void insert(char *s){
        int len=strlen(s),p=root;
        for (int i=0;i<len;i++){
            if (!tree[p].son[s[i]-'a']){
                tree[p].son[s[i]-'a']=++tot;
                tree[tot].fa=p;
            }
            p=tree[p].son[s[i]-'a'];
        }
    }
    void Get_Fail(){
        int head=1,tail=0;
        for (int i=0;i<26;i++){
            if (tree[root].son[i]){
                tree[tree[root].son[i]].fail=root;
                h[++tail]=tree[root].son[i];
            }
        }
        for (;head<=tail;head++){
            int Now=h[head];
            for (int i=0;i<26;i++){
                if (tree[Now].son[i]){
                    tree[tree[Now].son[i]].fail=tree[tree[Now].fail].son[i];
                    h[++tail]=tree[Now].son[i];
                }
                else    tree[Now].son[i]=tree[tree[Now].fail].son[i];
            }
        }
    }
    void solve(){
        for (int i=1;i<=tot;i++)
            for (int j=tree[i].fail;j;j=tree[j].fail)
                tree[j].size++;
        ll Ans=1ll*tot*tot;
        for (int i=1;i<=tot;i++){
            int j=i,k=tree[i].fail;
            if (!k) continue;
            while (k)   j=tree[j].fa,k=tree[k].fa;
            Ans-=tree[j].size;
        }
        printf("%lld\n",Ans);
    }
}AC;//Aho-Corasick automaton
char s[40];
int main(){
    int n=read();
    for (int i=1;i<=n;i++){
        scanf("%s",s);
        AC.insert(s);
    }
    AC.Get_Fail();
    AC.solve();
    return 0;
}