package main

import (
	"fmt"
	"io"
	"os"
)

const (
	M1 uint64 = 1000000007
	M2 uint64 = 1000000009
	B1 uint64 = 911382323
	B2 uint64 = 972663749
)

type Scanner struct {
	data []byte
	idx  int
}

func (s *Scanner) skip() {
	for s.idx < len(s.data) && s.data[s.idx] <= ' ' {
		s.idx++
	}
}

func (s *Scanner) NextInt() int {
	s.skip()
	n := 0
	for s.idx < len(s.data) && s.data[s.idx] > ' ' {
		n = n*10 + int(s.data[s.idx]-'0')
		s.idx++
	}
	return n
}

func (s *Scanner) NextBytes() []byte {
	s.skip()
	start := s.idx
	for s.idx < len(s.data) && s.data[s.idx] > ' ' {
		s.idx++
	}
	return s.data[start:s.idx]
}

func makeKey(str []byte, m int) string {
	var cnt [26]int
	for _, ch := range str {
		cnt[ch-'a']++
	}
	b := make([]byte, m)
	p := 0
	for c := 0; c < 26; c++ {
		ch := byte('a' + c)
		for t := 0; t < cnt[c]; t++ {
			b[p] = ch
			p++
		}
	}
	return string(b)
}

func oneOp(a, b []byte) bool {
	m := len(a)
	l := 0
	for l < m && a[l] == b[l] {
		l++
	}
	if l == m {
		return false
	}
	src, tgt := a, b
	if a[l] < b[l] {
		src, tgt = b, a
	}
	r := m - 1
	for src[r] == tgt[r] {
		r--
	}
	for i := l + 1; i <= r; i++ {
		if tgt[i-1] > tgt[i] {
			return false
		}
	}
	var diff [26]int
	for i := l; i <= r; i++ {
		diff[src[i]-'a']++
		diff[tgt[i]-'a']--
	}
	for i := 0; i < 26; i++ {
		if diff[i] != 0 {
			return false
		}
	}
	return true
}

func pack(h1, h2 uint64) uint64 {
	return (h1 << 32) | h2
}

func countGen(strs [][]byte, keys []string, freq map[string]int, m int) int64 {
	pow1 := make([]uint64, m+1)
	pow2 := make([]uint64, m+1)
	geom1 := make([]uint64, m+1)
	geom2 := make([]uint64, m+1)
	pow1[0], pow2[0] = 1, 1
	for i := 1; i <= m; i++ {
		pow1[i] = pow1[i-1] * B1 % M1
		pow2[i] = pow2[i-1] * B2 % M2
		geom1[i] = (geom1[i-1]*B1 + 1) % M1
		geom2[i] = (geom2[i-1]*B2 + 1) % M2
	}

	set := make(map[uint64]struct{}, len(strs)*2)
	for _, s := range strs {
		var h1, h2 uint64
		for _, ch := range s {
			v := uint64(ch-'a') + 1
			h1 = (h1*B1 + v) % M1
			h2 = (h2*B2 + v) % M2
		}
		set[pack(h1, h2)] = struct{}{}
	}

	pref1 := make([]uint64, m+1)
	pref2 := make([]uint64, m+1)
	var treeH1 [64]uint64
	var treeH2 [64]uint64
	var treeLen [64]int
	var cnt [26]int

	var ans int64
	for idx, s := range strs {
		if freq[keys[idx]] < 2 {
			continue
		}

		pref1[0], pref2[0] = 0, 0
		for i := 0; i < m; i++ {
			v := uint64(s[i]-'a') + 1
			pref1[i+1] = (pref1[i]*B1 + v) % M1
			pref2[i+1] = (pref2[i]*B2 + v) % M2
		}
		full1 := pref1[m]
		full2 := pref2[m]

		for l := 0; l < m; l++ {
			for i := 0; i < 64; i++ {
				treeH1[i] = 0
				treeH2[i] = 0
				treeLen[i] = 0
			}
			for i := 0; i < 26; i++ {
				cnt[i] = 0
			}

			minC, maxC := 26, -1
			leftChar := int(s[l] - 'a')
			prefixShifted1 := pref1[l] * pow1[m-l] % M1
			prefixShifted2 := pref2[l] * pow2[m-l] % M2

			for r := l; r < m; r++ {
				c := int(s[r] - 'a')
				if c < minC {
					minC = c
				}
				if c > maxC {
					maxC = c
				}

				cnt[c]++
				p := 32 + c
				treeLen[p] = cnt[c]
				treeH1[p] = uint64(c+1) * geom1[cnt[c]] % M1
				treeH2[p] = uint64(c+1) * geom2[cnt[c]] % M2

				for p >>= 1; p > 0; p >>= 1 {
					lc := p << 1
					rc := lc | 1
					treeLen[p] = treeLen[lc] + treeLen[rc]
					treeH1[p] = (treeH1[lc]*pow1[treeLen[rc]] + treeH1[rc]) % M1
					treeH2[p] = (treeH2[lc]*pow2[treeLen[rc]] + treeH2[rc]) % M2
				}

				if leftChar == minC || int(s[r]-'a') == maxC {
					continue
				}

				sufLen := m - r - 1
				suf1 := full1 + M1 - pref1[r+1]*pow1[sufLen]%M1
				if suf1 >= M1 {
					suf1 -= M1
				}
				suf2 := full2 + M2 - pref2[r+1]*pow2[sufLen]%M2
				if suf2 >= M2 {
					suf2 -= M2
				}

				cand1 := prefixShifted1 + treeH1[1]*pow1[sufLen]%M1
				if cand1 >= M1 {
					cand1 -= M1
				}
				cand1 += suf1
				if cand1 >= M1 {
					cand1 -= M1
				}

				cand2 := prefixShifted2 + treeH2[1]*pow2[sufLen]%M2
				if cand2 >= M2 {
					cand2 -= M2
				}
				cand2 += suf2
				if cand2 >= M2 {
					cand2 -= M2
				}

				if _, ok := set[pack(cand1, cand2)]; ok {
					ans++
				}
			}
		}
	}

	return ans
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	sc := Scanner{data: data}

	n := sc.NextInt()
	strs := make([][]byte, n)
	for i := 0; i < n; i++ {
		strs[i] = sc.NextBytes()
	}
	m := len(strs[0])

	keys := make([]string, n)
	freq := make(map[string]int, n)
	var anagramPairs int64
	for i := 0; i < n; i++ {
		key := makeKey(strs[i], m)
		keys[i] = key
		anagramPairs += int64(freq[key])
		freq[key]++
	}

	multi := 0
	for _, c := range freq {
		if c > 1 {
			multi += c
		}
	}

	genCost := int64(multi) * int64(m) * int64(m+1) / 2 * 6
	pairCost := anagramPairs * int64(m)

	var oneOpPairs int64
	if pairCost <= genCost {
		groups := make(map[string][]int, len(freq))
		for i := 0; i < n; i++ {
			if freq[keys[i]] > 1 {
				groups[keys[i]] = append(groups[keys[i]], i)
			}
		}
		for _, idxs := range groups {
			for i := 0; i < len(idxs); i++ {
				s1 := strs[idxs[i]]
				for j := i + 1; j < len(idxs); j++ {
					if oneOp(s1, strs[idxs[j]]) {
						oneOpPairs++
					}
				}
			}
		}
	} else {
		oneOpPairs = countGen(strs, keys, freq, m)
	}

	totalPairs := int64(n) * int64(n-1) / 2
	ans := 1337*totalPairs - 1335*anagramPairs - oneOpPairs
	fmt.Println(ans)
}