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


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.TreeMap;

public class R170B {

    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

    public static void main(String[] args) throws IOException {

        int num = Integer.parseInt(reader.readLine());

        Trie t = new Trie();

        for (int i = 0; i < num; i++) {
            String s = reader.readLine();
            for (int j = 0; j < s.length(); j++) {
                t.insert(s, j);
            }
        }

        LinkedList<Node> queue = new LinkedList<Node>();

        queue.add(t.root);

        Node resultNode = null;


        while (resultNode == null) {
            Node n = queue.pollFirst();
            char c = 'a';
            for (Node child : n.children.values()) {
                if (child.c > c) {
                    break;
                }
                queue.addLast(child);
                c++;
            }
            if (c <= 'z') {
                resultNode = n.getOrCreateChild(c);
            }
        }

        LinkedList<Character> chars = new LinkedList<Character>();

        while (resultNode != null && resultNode.c != null) {
            chars.addFirst(resultNode.c);
            resultNode = resultNode.parent;
        }

        for (Character c : chars) {
            System.out.print(c);
        }
        System.out.println();


    }

    public static class Node implements Comparable<Node> {

        Character c = null;
        Node parent = null;
        TreeMap<Character, Node> children = null;

        public Node() { }

        public Node(Character c, Node parent) {
            this.c = c;
            this.parent = parent;
        }

        public Node getOrCreateChild(char c) {

            if (children == null) {
                children = new TreeMap<Character, Node>();
            }

            if (children.containsKey(c)) {
                return children.get(c);
            } else {
                Node child = new Node(c, this);
                children.put(c, child);
                return child;
            }
        }

        @Override public String toString() {
            return (parent != null ? parent.toString() : "") + (c != null ? c : "");
        }

        @Override public int compareTo(Node o) {
            return c - o.c;
        }

    }

    public static class Trie {

        Node root = new Node();

        public void insert(String str, int start) {
            Node node = root;

            for (int i = 0; i < str.length() - start; i++) {
                char c = str.charAt(i + start);
                node = node.getOrCreateChild(c);
            }
        }

    }

}
