3
rjnflsbpxqivrcdjptj
vpojopbwbwbswdu
rydkiwnugwddcgcrng
 1
z
 30
b
u
p
n
f
m
t
i
j
k
p
h
a
c
w
z
z
p
t
d
o
w
u
q
l
y
i
o
a
u
 5
splt
ohqykk
xqpz
knojbur
pmfm
 2
hk
obsp
 5
zzxpfk
abcdefghijklmnopqrst
uvwxz
srgkjaskldfkln
vgnsdfdgfh
 2
rxscdzkkezud
wjehahqgouqvjienq
 5
ojdfhi
abcdefghijklmnopqrst
uvwxyz
ddfhdfhlasjt
qqq
 1
epkotfpkkrhhmuipmtdk
 10
kpmwcdoysw
gtpr
kuzoxmiixxbl
crgqtuo
jhbplhpklrgwnaugdf
zuxdaat
aycv
qwghrkqwkobrgevsjrk
tdxgc
lxyzgcmbzulcst
 5
dfijdfhi
abcdefghijklmnopqrst
uvwxy
kopsdfgiopjipw
jty
 2
xlaxwpjabtpwddc
txwdjmohrrszorrnomc
 1
a
 30
waiphwcqrrinr
o
qiqehzmgsjdoqd
kjexeesevrlowxhghq
judikhzkj
z
xo
lsdzypkfqro
sshgcxsky
gecntpcmoojfwp
svmytmcfhc
jrsrvsvbaiumlmkptn
s
wpcsovfjlyspviflk
ktvyzvddgllht
szahigtmklglrcocbo
znligfxkgxzkcfeu
liryvzmqwhr
xgrxkgiehxztv
etrjxdczppafly
jrdgajschhwsci
doxnxbjwptnimjmsuijx
zciwkbvrhgsjhrr
ehh
bzlnmd
xpbtbpftimnn
khbknqbvdkdd
mldj
skrvnyz
avptgpjmenfzfxwckmt
 30
e
x
itaubd
xcn
v
x
i
ci
aqs
zbi
q
cvdu
a
jos
qy
fjf
nayke
ge
s
q
qwad
gvz
o
ubn
nzoc
h
wnjwjrf
t
bq
bw
 1
b

a
 a
 e
 a
 a
 y
 b
 aa
 a
 ab
 z
 e
 b
 aa
 l
 a

//package codeforces.ru.task_278B;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

/**
 * Created by myduomilia on 10.08.14.
 */
public class Main {
    public static void main(String[] args) throws IOException {
        FastReadWriteConsole console = new FastReadWriteConsole();
        int n = console.readInt();
        StringBuffer sb = new StringBuffer();
        for(int i = 0; i < n; i++){
            sb.append(console.readString()).append('#');
        }
        sb.append("$");
        SuffixTreeUkkonen suffixTree = new SuffixTreeUkkonen();
        suffixTree.buildSuffixTree(sb.toString());
        System.out.println(suffixTree.solve());
        console.close();
    }
}
class SuffixTreeUkkonen {

    static final String ALPHABET = "abcdefghijklmnopqrstuvwxyz$#";

    private String text;

    private Node root;

    private byte arr[];

    public static class Node {
        int begin;
        int end;
        int depth;
        Node parent;
        Node[] children;
        Node suffixLink;

        Node(int begin, int end, int depth, Node parent) {
            children = new Node[ALPHABET.length()];
            this.begin = begin;
            this.end = end;
            this.parent = parent;
            this.depth = depth;
        }

        boolean contains(int d) {
            return depth <= d && d < depth + (end - begin);
        }
    }

    private void dfs(Node node, List<Integer> list){
        boolean bool = true;
        for(int i = 0; i < node.children.length; i++){
            if(node.children[i] != null){
                dfs(node.children[i], list);
                bool = false;
            }
        }
        if(bool){
            list.add(node.begin - node.depth);
        }
    }

    public String solve(){
        int ans = -1;
        Node prev = null;
        LinkedList<Node> q = new LinkedList<Node>();
        q.add(root);
        while (!q.isEmpty() && ans == -1){
            Node node = q.getFirst();
            Node children[] = node.children;
            for(int i = 0 ; i < children.length - 2; i++){
                if(children[i] == null){
                    ans = i;
                    prev = node;
                    break;
                }else{
                    q.add(children[i]);
                }
            }
            q.removeFirst();
        }
        StringBuffer sb = new StringBuffer();
        sb.append((char)(ans + 'a'));
        while(prev.parent != null){
            sb.append(text.charAt(prev.begin));
            prev = prev.parent;
        }
        return sb.reverse().toString();
    }

    public void buildSuffixTree(String text) {
        this.text = text;
        int n = text.length();
        arr = new byte[n];
        for (int i = 0; i < n; i++){
            arr[i] = (byte) ALPHABET.indexOf(text.charAt(i));
        }
        root = new Node(0, 0, 0, null);
        Node cn = root;
        root.suffixLink = root;
        Node needsSuffixLink = null;
        int lastRule = 0;
        int j = 0;
        for (int i = -1; i < n - 1; i++) {
            int cur = arr[i + 1];
            for (; j <= i + 1; j++) {
                int curDepth = i + 1 - j;
                if (lastRule != 3) {
                    cn = cn.suffixLink != null ? cn.suffixLink : cn.parent.suffixLink;
                    int k = j + cn.depth;
                    while (curDepth > 0 && !cn.contains(curDepth - 1)) {
                        k += cn.end - cn.begin;
                        cn = cn.children[arr[k]];
                    }
                }
                if (!cn.contains(curDepth)) {
                    if (needsSuffixLink != null) {
                        needsSuffixLink.suffixLink = cn;
                        needsSuffixLink = null;
                    }
                    if (cn.children[cur] == null) {
                        cn.children[cur] = new Node(i + 1, n, curDepth, cn);
                        lastRule = 2;
                    } else {
                        cn = cn.children[cur];
                        lastRule = 3;
                        break;
                    }
                } else {
                    int end = cn.begin + curDepth - cn.depth;
                    if (arr[end] != cur) {
                        Node newn = new Node(cn.begin, end, cn.depth, cn.parent);
                        newn.children[cur] = new Node(i + 1, n, curDepth, newn);
                        newn.children[arr[end]] = cn;
                        cn.parent.children[arr[cn.begin]] = newn;
                        if (needsSuffixLink != null) {
                            needsSuffixLink.suffixLink = newn;
                        }
                        cn.begin = end;
                        cn.depth = curDepth;
                        cn.parent = newn;
                        cn = needsSuffixLink = newn;
                        lastRule = 2;
                    } else if (cn.end != n || cn.begin - cn.depth < j) {
                        lastRule = 3;
                        break;
                    } else {
                        lastRule = 1;
                    }
                }
            }
        }
        root.suffixLink = null;
    }

}
class FastReadWriteConsole {

    BufferedReader in;
    StringTokenizer tok;
    PrintWriter out;

    public FastReadWriteConsole() {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
    }

    private String readToken() throws IOException {
        while (tok == null || !tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    public int readInt() throws IOException {
        return Integer.parseInt(readToken());
    }

    public String readString() throws IOException {
        return readToken();
    }

    public void write(Object obj){
        out.print(obj.toString());
    }

    public static void main(String[] args) throws IOException {
        FastReadWriteConsole fastReadWriteConsole = new FastReadWriteConsole();
        int a = fastReadWriteConsole.readInt();
        fastReadWriteConsole.write(a);
    }

    public void close() throws IOException {
        in.close();
        out.close();
    }

}
