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;
template <class T, class U>
inline void Max(T& a, U b) {
  if (a < b) a = b;
}
template <class T, class U>
inline void Min(T& a, U b) {
  if (a > b) a = b;
}
int n;
set<string> st;
string s;
int a[26];
bool check(string& s) {
  memset(a, 0, sizeof a);
  for (int i = 0; i < s.length(); ++i) {
    if (++a[s[i] - 'a'] > 1) return false;
  }
  return true;
}
long long string_key(const string& s) {
  long long res = 0;
  for (int i = 0; i < s.length(); ++i) {
    res += (1LL << (s[i] - 'a'));
  }
  return res;
}
pair<string, bool> mergeTwo(string& s1, string& s2, char c) {
  int pos1 = s1.find_first_of(c);
  int pos2 = s2.find_first_of(c);
  int i1 = pos1, i2 = pos2, j1 = pos1, j2 = pos2;
  while (i1 >= 0 && i2 >= 0) {
    if (s1[i1--] != s2[i2--]) {
      return {"", false};
    }
  }
  while (j1 < s1.length() && j2 < s2.length()) {
    if (s1[j1++] != s2[j2++]) {
      return {"", false};
    }
  }
  if (i1 < 0) {
    if (j1 == s1.length()) {
      if (check(s2))
        return {s2, true};
      else
        return {"", false};
    } else {
      auto res = s2 + s1.substr(j1);
      if (check(res))
        return {res, true};
      else
        return {"", false};
    }
  } else {
    if (j1 == s1.length()) {
      auto res = s1 + s2.substr(j2);
      if (check(res))
        return {res, true};
      else
        return {"", false};
    } else {
      if (check(s1))
        return {s1, true};
      else
        return {"", false};
    }
  }
}
pair<string, bool> merge(vector<string>& vs, char c) {
  int n = vs.size();
  string res = vs[0];
  for (int i = 1; i < n; ++i) {
    auto cur_res = mergeTwo(res, vs[i], c);
    if (!cur_res.second) return {"", false};
    res = cur_res.first;
  }
  return {res, true};
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cin >> n;
  for (int i = 0; i < n; ++i) {
    cin >> s;
    if (!check(s)) {
      cout << "NO" << endl;
      return 0;
    }
    st.insert(s);
  }
  for (char c = 'a'; c <= 'z'; ++c) {
    long long mask = (1LL << (c - 'a'));
    vector<string> to_merge;
    for (auto it = st.begin(); it != st.end();) {
      if (mask & string_key(*it)) {
        to_merge.push_back(*it);
        it = st.erase(it);
      } else {
        ++it;
      }
    }
    if (to_merge.size() < 2) {
      if (to_merge.size()) st.insert(to_merge[0]);
      continue;
    }
    pair<string, bool> cur_res = merge(to_merge, c);
    if (!cur_res.second) {
      cout << "NO" << endl;
      return 0;
    }
    st.insert(cur_res.first);
  }
  string res = "";
  for (auto it = st.begin(); it != st.end(); ++it) {
    res += *it;
  }
  cout << res << endl;
}
