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.
#https://codeforces.com/problemset/problem/886/D
def is_all_used(used):
    for val in used.values():
        if val != True:
            return False
    return True    

def is_circle(d, pre):
    used     = {x:False for x in d}
    pre_none = [x for x in used if x not in pre]
    s_arr    = []
    
    for x in pre_none:
        cur    = []
        flg    = dfs(x, d, used, cur)
            
        if flg==True:
            return True, None
            
        s_arr.append(cur)
    
    if is_all_used(used) != True:
        return True, None
    
    return False, s_arr

def dfs(u, d, used, cur):
    used[u] = True
    cur.append(u)
    flg = False
    
    for v in d[u]:
        if used[v] == True:
            return True
        
        flg = dfs(v, d, used, cur)
        
        if flg==True:
            return flg
    return flg

def push(d, u, v=None):
    if u not in d:
        d[u] = set()
    
    if v is not None:
        if v not in d:
            d[v] = set()
        d[u].add(v)
    
def push_p(d, v):
    if v not in d:
        d[v] = 0
    d[v]+=1
    
def is_deg_valid(d):
    for u in d:
        if len(d[u]) > 1:
            return True
    return False

def solve():
    n   = int(input())
    d   = {}
    pre = {}
    
    for _ in range(n):
        s = input()
        if len(s) == 1:
            push(d, s)
        else:
            for u, v in zip(s[:-1], s[1:]):
                push(d, u, v)
                push_p(pre, v)
    
    flg, arr = is_circle(d, pre)
    
    if is_deg_valid(d) or flg==True:
        return 'NO'
    
    S = [''.join(x) for x in arr]
    S = sorted(S)
    return ''.join([s for s in S])
        
print(solve())

#4
#mail
#ai
#lru
#cf

#3
#kek
#preceq
#cheburek