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

struct RollingHash {
  static constexpr long long m31 = (1LL << 31) - 1;
  static int mod_m31(long long a) {
    a = (a >> 31) + (a & m31);
    return a >= m31 ? a - m31 : a;
  }
  static long long base[2];
  static vector<int> powb[2];
  vector<int> h[2];
  RollingHash(const string& s) : h{{0}, {0}} {
    for (int k : {0, 1}) {
      for (char c : s) h[k].push_back(mod_m31(h[k].back() * base[k] + c));
      while (powb[k].size() <= s.size())
        powb[k].push_back(mod_m31(powb[k].back() * base[k]));
    }
  }
  int get(int l, int r, int k) const {
    return mod_m31(h[k][r] + (m31 - h[k][l]) * powb[k][r - l]);
  }
  auto get(int l, int r) const { return make_pair(get(l, r, 0), get(l, r, 1)); }
};
long long RollingHash::base[2] = {1095803926, 1410736294};
vector<int> RollingHash::powb[2] = {{1}, {1}};

template <class T, T Op(T, T)> struct SparseTable {
  vector< vector<T> > t;
  SparseTable(const vector<T>& v) : t{v} {
    for (int k = 1, n = v.size(); 1 << k <= n; ++k) {
      t.emplace_back(n - (1 << k) + 1);
      for (int i = 0; i + (1 << k) <= n; ++i)
        t[k][i] = Op(t[k - 1][i], t[k - 1][i + (1 << (k - 1))]);
    }
  }
  T fold(int l, int r) const {
    assert(l < r);
    int k = __lg(r - l);
    return Op(t[k][l], t[k][r - (1 << k)]);
  }
};
int minimum(int a, int b) { return b < a ? b : a; }

int main() {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  int n;
  cin >> n;
  vector<string> s(n);
  vector<RollingHash> rh;
  for (auto&& e : s) {
    cin >> e;
    rh.emplace_back(e);
  }
  vector<int> v(n - 1);
  for (int i = 0; i < n - 1; ++i) {
    int ok = 0, ng = min(s[i].size(), s[i + 1].size()) + 1;
    while (ng - ok > 1) {
      int mid = (ok + ng) / 2;
      (rh[i].get(0, mid) == rh[i + 1].get(0, mid) ? ok : ng) = mid;
    }
    v[i] = ok;
  }
  long long res = 0;
  SparseTable<int, minimum> st(v);
  for (int i = 0; i < n; ++i) {
    int m = s[i].size();
    for (int j = 0; j < m; ++j) {
      int ok = i, ng = n;
      while (ng - ok > 1) {
        int mid = (ok + ng) / 2;
        (st.fold(i, mid) > j ? ok : ng) = mid;
      }
      ok = ok - i + 1;
      res += (long long)ok * (ok + 1) / 2;
    }
  }
  cout << res << '\n';
}