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.
#include <bits/stdc++.h>
using namespace std;
void merge(string& a, string& b, char c) {
  if (b == "") return;
  if (a == "") {
    swap(b, a);
    return;
  }
  int i1 = -1, i2 = -1;
  for (int i = 0; i < a.length(); ++i)
    if (a[i] == c) {
      i1 = i;
      break;
    }
  for (int i = 0; i < b.length(); ++i)
    if (b[i] == c) {
      i2 = i;
      break;
    }
  int idx = 0;
  while (i1 - idx >= 0 && i2 - idx >= 0) {
    if (a[i1 - idx] != b[i2 - idx]) {
      cout << "NO\n";
      exit(0);
    }
    ++idx;
  }
  idx = 0;
  while (i1 + idx < a.length() && i2 + idx < b.length()) {
    if (a[i1 + idx] != b[i2 + idx]) {
      cout << "NO\n";
      exit(0);
    }
    ++idx;
  }
  if (i2 > i1) {
    swap(a, b);
    swap(i2, i1);
  }
  while (a.length() + i2 < b.length() + i1) {
    a += b[a.length() - i1 + i2];
  }
  b = "";
  int mask = 0;
  for (int j = 0; j < a.length(); ++j) {
    int c = a[j] - 'a';
    if (mask & (1 << c)) {
      cout << "NO\n";
      exit(0);
    }
    mask |= (1 << c);
  }
}
void merge(int a, int b, vector<int>& p) { p[b] = a; }
int getP(int a, vector<int>& p) {
  return (a == p[a] ? a : (p[a] = getP(p[a], p)));
}
int main() {
  while (false) {
    string a, b, c;
    cin >> a >> b >> c;
    merge(a, b, c[0]);
    cout << a << " " << b << "\n";
  }
  int n;
  scanf("%d", &n);
  vector<string> inp(n);
  vector<int> idx[26];
  for (int i = 0; i < n; ++i) {
    cin >> inp[i];
    int mask = 0;
    for (int j = 0; j < inp[i].length(); ++j) {
      int c = inp[i][j] - 'a';
      if (mask & (1 << c)) {
        cout << "NO\n";
        return 0;
      }
      mask |= (1 << c);
      idx[c].push_back(i);
    }
  }
  vector<int> p(n);
  for (int i = 0; i < n; ++i) p[i] = i;
  for (int c = 0; c < 26; ++c) {
    if (idx[c].size() < 2) continue;
    for (int j = 1; j < idx[c].size(); ++j) {
      int i1 = getP(idx[c][0], p);
      int i2 = getP(idx[c][j], p);
      if (i1 == i2) continue;
      merge(inp[i1], inp[i2], c + 'a');
      merge(i1, i2, p);
    }
  }
  vector<string> ans;
  for (string s : inp)
    if (s != "" && !s.empty()) {
      ans.push_back(s);
    }
  sort(ans.begin(), ans.end());
  for (string s : ans) cout << s;
  cout << "\n";
  return 0;
}
