Problem:
Score : 700 points

Problem Statement

Limak can repeatedly remove one of the first two characters of a string,
for example abcxyx \rightarrow acxyx \rightarrow cxyx \rightarrow cyx.

You are given N different strings S_1, S_2, \ldots, S_N.
Among N \cdot (N-1) / 2 pairs (S_i, S_j),
in how many pairs could Limak obtain one string from the other?

Constraints

2 \leq N \leq 200\,000

S_i consists of lowercase English letters a-z.

S_i \neq S_j

1 \leq |S_i|

|S_1| + |S_2| + \ldots + |S_N| \leq 10^6

Input

Input is given from Standard Input in the following format.

N
S_1
S_2
\vdots
S_N

Output

Print the number of unordered pairs (S_i, S_j)
where i \neq j and Limak can obtain one string from the other.

Sample Input 1

3
abcxyx
cyx
abc

Sample Output 1

1

The only good pair is (abcxyx, cyx).

Sample Input 2

6
b
a
abc
c
d
ab

Sample Output 2

5

There are five good pairs: (b, abc), (a, abc), (abc, c), (b, ab), (a, ab).

Solution in Go (1.14.1) (judge verdict: Runtime Error)

package main

import (
	"bufio"
	"fmt"
	"os"
	"reflect"
)

func main() {
	n, an, an2 := 0, 0, 0
	var s []string
	fmt.Scanf("%d", &n)
	sc := bufio.NewScanner(os.Stdin)
	for i := 0; i < n; i++ {
		sc.Scan()
		s = append(s, sc.Text())
	}
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			if i == j {
				continue
			}
			if s[i] == s[j] {
				an2++
				continue
			}
			if fs(s[i], s[j]) {
				an++
			}
		}
	}
	fmt.Println(an + an2/2)
}
func fs(as, bs string) bool {
	a := []byte(as)
	b := []byte(bs)
	if len(b) == 1 {
		for _, i := range a {
			if i == b[0] {
				return true
			}
		}
		return false
	}
	if len(b) == 2 {
		if !(a[len(a)-1] == b[1]) {
			return false
		}
		var tmp int
		for _, i := range a {
			if i == b[0] {
				tmp = 1
			}
			if tmp == 1 && i == b[1] {
				return true
			}
		}
	}
	for {
		if len(a) > 1 {
			if a[0] == b[0] {
				break
			}

			a = a[1:]
		} else {
			return false
		}
	}
	for {
		if len(a) > 2 {
			if a[1] == b[1] {
				if reflect.DeepEqual(a, b) {
					return true
				} else {
					return false
				}
			}
			tmp := a[1]
			a = a[1:]
			a[1] = tmp
		} else {
			return false
		}
	}
}