'''input
2
ac
bc
'''

import sys
pow2 = pow              # for modular expo pow2(base, n, mod)
from math import *
from time import time
from collections import defaultdict
from bisect import bisect_right, bisect_left
from string import ascii_lowercase as lcs
from string import ascii_uppercase as ucs
from fractions import Fraction, gcd
from decimal import Decimal, getcontext
from itertools import product, permutations, combinations
#getcontext().prec = 500
#sys.setrecursionlimit(30000)

# What doesn't challenge you, makes you weaker.

mod = 10**9 + 7
INF = sys.maxint

raw_input = lambda: sys.stdin.readline().rstrip()
die = lambda : exit(0)
flush= lambda : sys.stdout.flush()

r_s = lambda: raw_input().strip()                   #read str
r_ss = lambda: raw_input().split()          #read stringss
r_i = lambda: int(raw_input())              #read int
r_is = lambda: map(int, raw_input().split())#read ints
r_f = lambda: float(raw_input())            #read float
r_fs = lambda: map(Decimal, raw_input().split()) #read floats

# For effieciently taking lots of queries with each query in a separate line
# having integer values separated by space. A 2d list is made with each row
# corresponding to line. Each row is a list with all the values.
# Use this for fast I/O by taking all input in one go.
r_qs = lambda: map(lambda s:map(int, s.split(' ')), sys.stdin.readlines())

'''-------------------------------------------------------------------'''

# Call it as dbg(varName=varName)
def dbg(**kwargs):
    print "Value of '" + kwargs.keys()[0] + "' is", kwargs[kwargs.keys()[0]]

def main():
    n = r_i()
    words = []
    for i in range(n):
        words.append(r_s())
    # Directed graph with nodes as all the letters
    graph = defaultdict(set)
    letters= set()
    for word in words:
        prev = word[0]
        letters.add(prev)
        for letter in word[1:]:
            letters.add(letter)
            graph[prev].add(letter)
            prev = letter
    stack = [0 for i in range(26)]
    seen = set()
    start = [1 for i in range(26)]  # Will have 0 for any node which has incoming edged after dfs
    def dfs(root):
        seen.add(root)
        stack[ord(root)-ord('a')] = 1
        for neigh in graph[root]:
            if stack[ord(neigh)-ord('a')]:
                print "NO"
                die()
            start[ord(neigh)-ord('a')] = 0
            dfs(neigh)
        stack[ord(root)-ord('a')] = 0

    for letter in letters:
        if letter not in seen:
            dfs(letter)
    # print graph
    ans = []
    for pos in range(26):
        if start[pos] == 1:
            letter = chr(pos+ord('a'))
        if letter not in letters:
            continue
        temp = ''
        prev = letter
        while prev!='':
            new = prev
            temp += new
            letters.remove(new)
            if len(graph[new])>1:
                print "NO"
                die()
            for neigh in graph[new]:
                if neigh in letters:
                    prev = neigh
                    break
                else:
                    print "NO"
                    die()
            else:
                prev = ''
        ans.append(temp)
    ans.sort()
    ans = ''.join(ans)
    print ans




if __name__ == '__main__':
    # local = True
    local = False
    if local:
        try:
            sys.stdin = open('input.txt')
            print 'Running at local.'
            for i in range(r_i()):
                main()
        except IOError:
            main()
    else:
        main()


