josdas

#define _CRT_SECURE_NO_WARNINGS
#pragma comment(linker, "/STACK:66777216")
#include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <ctime>
#include <map>
#include <set>
#include <string>
#include <queue>
#include <deque>
#include <cassert>
#include <cstdlib>
#include <bitset>
#include <algorithm>
#include <string>
#include <list>
#include <fstream>
#include <unordered_set>

using namespace std;

typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;

#define forn(i, n) for (int i = 0; i < (ll)n; i++)
#define fornn(i, q, n) for (int i = q; i < (ll)n; i++)
#define mp make_pair
#define pk push_back
#define all(v) v.begin(), v.end()
#define times clock() * 1.0 / CLOCKS_PER_SEC
#define mk make_pair
#define inb push_back
#define outb pop_back

#define TASK "race"

const double eps = 1e-7;
const double pi = acos(-1.0);

const int inf = (int)2e9 + 1;
const ll linf = (ll)9e18 + 7;
const ll dd = 2e5 + 5;
const ll MM = (ll)1e9 + 7;
const ll mod = (ll)1e9 + 7;
const ll p1 = 31;

int solve();
void gen();

int main() {
#ifdef _DEBUG
    freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout);
#else
    freopen(TASK".in", "r", stdin), freopen(TASK".out", "w", stdout);
    //freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout), freopen("test.txt", "w", stderr);
#endif
    solve();
    return 0;
}

struct tr{
    vector<vector<pair<char, int> > > Z;
    vector<string> G;
    vector<ll> H, S, dp;
    vector<int> W;
    multiset<ll> T;
    int g = 1;

    tr(){
        T.insert(0);
        W.resize(1);
        H.resize(1);
        S.resize(1);
        G.resize(1);
        dp.resize(1);
        Z.resize(1);
    }
    void add(string t){
        G.push_back(t);
        int v = 0;
        vector<int> Q;
        Q.push_back(0);
        for (int i = 0; i < t.size(); i++){
            int d = -1;
            forn(j, Z[v].size()){
                if (Z[v][j].first == t[i]){
                    d = Z[v][j].second;
                    break;
                }
            }
            if (d >= 0){
                v = d;
                if (i == (t.size() - 1))
                    W[v]++;
            }
            else{
                Z[v].push_back(mk(t[i], g));
                v = g;
                S.push_back(0);
                H.push_back(i + 1);
                dp.push_back(0);
                T.insert(0);
                W.push_back(i == (t.size() - 1));
                Z.push_back(vector<pair<char, int> >());
                g++;
            }
            Q.push_back(v);
        }
        for (int i = Q.size() - 1; i >= 0; i--){
            int t = Q[i];
            T.erase(T.find(dp[t]));
            ll s = W[t];
            forn(j, Z[t].size()){
                s += S[Z[t][j].second];
            }
            S[t] = s;
            dp[t] = s * H[t];
            T.insert(dp[t]);
        }
    }
};

struct trr{
    vector<vector<pair<char, int> > > Z;
    vector<vector<int> > Q;
    int g = 1;

    trr(){
        Q.resize(1);
        Z.resize(1);
    }
    void add(string t, int gg){
        int v = 0;
        for (int i = 0; i < t.size(); i++){
            int d = -1;
            forn(j, Z[v].size()){
                if (Z[v][j].first == t[i]){
                    d = Z[v][j].second;
                    break;
                }
            }
            if (d >= 0){
                v = d;
                if (i == t.size() - 1)
                    Q[v].push_back(gg);
            }
            else{
                Z[v].push_back(mk(t[i], g));
                v = g;
                g++;
                Q.push_back(vector<int>());
                Z.push_back(vector<pair<char, int> >());
                if (i == t.size() - 1)
                    Q[v].push_back(gg);
            }
        }
    }
} Ro;

ll res = 0;
vector<string> Gg, Rg;

tr *dfs(int v, ll h){
    tr *qw = new tr();
    forn(i, Ro.Q[v].size()){
        qw->add(Rg[Ro.Q[v][i]]);
    }
    forn(i, Ro.Z[v].size()){
        auto t = dfs(Ro.Z[v][i].second, h + 1);
        if (qw->g < t->g)
            swap(qw, t);
        forn(i, t -> G.size()){
            qw->add(t->G[i]);
        }
    }
    if (qw->T.size())
        res = max(res, (*(qw->T.rbegin())) * h);
    return qw;
}

int n;
int solve() {
    cin >> n;
    Gg.resize(n);
    forn(i, n){
        string t;
        cin >> t;
        Ro.add(t, i);
        reverse(t.begin(), t.end());
        Rg.push_back(t);
    }
    dfs(0, 0);
    cout << res;
    return 0;
}