A substring of some string is called the most frequent, if the number of its occurrences is not less than number of occurrences of any other substring.

You are given a set of strings. A string (not necessarily from this set) is called good if all elements of the set are the most frequent substrings of this string. Restore the non-empty good string with minimum length. If several such strings exist, restore lexicographically minimum string. If there are no good strings, print "NO" (without quotes).

A substring of a string is a contiguous subsequence of letters in the string. For example, "ab", "c", "abc" are substrings of string "abc", while "ac" is not a substring of that string.

The number of occurrences of a substring in a string is the number of starting positions in the string where the substring occurs. These occurrences could overlap.

String a is lexicographically smaller than string b, if a is a prefix of b, or a has a smaller letter at the first position where a and b differ.

Input

The first line contains integer n (1 ≤ n ≤ 105) — the number of strings in the set.

Each of the next n lines contains a non-empty string consisting of lowercase English letters. It is guaranteed that the strings are distinct.

The total length of the strings doesn't exceed 105.

Output

Print the non-empty good string with minimum length. If several good strings exist, print lexicographically minimum among them. Print "NO" (without quotes) if there are no good strings.

Examples

Input

4
mail
ai
lru
cf


Output

cfmailru


Input

3
kek
preceq
cheburek


Output

NO

Note

One can show that in the first sample only two good strings with minimum length exist: "cfmailru" and "mailrucf". The first string is lexicographically minimum.
import sys

def no():
    print('NO')
    sys.exit(0)


def align(s, t, i, j):
    if i < j:
        i, j = j, i
        s, t = t, s

    result = s[:i - j]
    s = s[i - j:]

    for k in range(max(len(s), len(t))):
        if k < len(s) and k < len(t):
            if s[k] != t[k]:
                no()
        result += s[k] if k < len(s) else t[k]

    return result

n = int(input())

s = set()
for i in range(n):
    cur = input()

    if len(set(cur)) != len(cur):
        no()

    any_changes = True
    while any_changes:
        any_changes = False
        # Words intersect
        for x in s:
            if set(x) & set(cur):
                any_changes = True
                min_new_string = None
                s.remove(x)

                for i in range(len(x)):
                    for j in range(len(cur)):
                        if x[i] != cur[j]:
                            continue

                        t = align(x, cur, i, j)
                        if len(set(t)) == len(t) and (min_new_string 
                                is None or min_new_string > t):
                            min_new_string = t

                if min_new_string is None:
                    no()
                cur = min_new_string
                break

    s.add(cur)


print(''.join(sorted(s)))


