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.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

public class R170_B implements Runnable{
    
    private void solve() throws IOException {
        int N = scanner.nextInt();
        StringBuilder builder = new StringBuilder();
        
//      String[] words = new String[N];
        for (int i = 0; i < N; i++) {
//          words[i] = scanner.nextToken();
            builder.append(scanner.nextToken() + "|");
        }
        
        String wordsSequence = builder.toString();
        
        char[] sequence = {'a'};
        boolean found = false;
        while(!found) {
//          boolean isSubstring = false;
//          for (String word : words) {
//              if (word.indexOf(new String(sequence)) > -1) {
//                  isSubstring = true;
//                  break;
//              }
//          }
//          if (isSubstring) sequence = increase(sequence); 
//          else found = true;
            if (wordsSequence.contains(new String(sequence))) sequence = increase(sequence);
            else { 
                found = true;
                break;
            }
        }
        out.println(sequence);
    }
    
    private char[] increase(char[] sequence) {
        boolean changed = false;
        for (int i = sequence.length-1; i >= 0; i--) {
            if (sequence[i] < 'z') {
                sequence[i]++;
                changed = true;
                break;
            } else if (sequence[i] == 'z') {
                sequence[i] = 'a';
            }
        }
        if (!changed) {
            char[] copy = new char[sequence.length+1];
            for (int i = 0; i < copy.length; i++) {
                copy[i] = 'a';
            }
            sequence = copy;
        }
        return sequence;
    }

    /////////////////////////////////////////////////
    final int BUF_SIZE = 1024 * 1024 * 8;//important to read long-string tokens properly
    final int INPUT_BUFFER_SIZE = 1024 * 1024 * 8 ;
    final int BUF_SIZE_INPUT = 1024;
    
    final int BUF_SIZE_OUT = 1024;
    
    boolean inputFromFile = false;
    String filenamePrefix = "A-small-attempt0";
    String inSuffix = "in.txt";
    String outSuffix = "out.txt";
    
    //InputStream bis;
    //OutputStream bos;
    PrintStream out;
    ByteScanner scanner;
    ByteWriter writer;
    
//  @Override
    public void run() {
        try{
            InputStream bis = null;
            OutputStream bos = null;
            //PrintStream out = null;
            if (inputFromFile){
                File baseFile = new File(getClass().getResource("/").getFile());
                bis = new BufferedInputStream(
                        new FileInputStream(new File(
                                baseFile, filenamePrefix+inSuffix)),
                                INPUT_BUFFER_SIZE);
                bos = new BufferedOutputStream(
                        new FileOutputStream(
                                new File(baseFile, filenamePrefix+outSuffix)));
                out = new PrintStream(bos);
            }else{
                bis = new BufferedInputStream(System.in, INPUT_BUFFER_SIZE);
                bos = new BufferedOutputStream(System.out);
                out = new PrintStream(bos);
            }
            scanner = new ByteScanner(bis, BUF_SIZE_INPUT, BUF_SIZE);
            writer = new ByteWriter(bos, BUF_SIZE_OUT);
            
            solve();
            out.flush();
        }catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }
    
    public interface Constants {
        final static byte ZERO = '0';//48 or 0x30
        final static byte NINE = '9';
        final static byte SPACEBAR = ' '; //32 or 0x20
        final static byte MINUS = '-'; //45 or 0x2d 
        
        final static char FLOAT_POINT = '.';
    }
    
    public static class EofException extends IOException{
    }
    
    public static class ByteWriter implements Constants {
        
        int bufSize = 1024;
        byte[] byteBuf = new byte[bufSize];
        OutputStream os;
        
        public ByteWriter(OutputStream os, int bufSize){
            this.os = os;
            this.bufSize = bufSize;
        }
        
        public void writeInt(int num) throws IOException{
             int byteWriteOffset = byteBuf.length;
             if (num==0){
                 byteBuf[--byteWriteOffset] = ZERO;
             }else{
                 int numAbs = Math.abs(num);
                 while (numAbs>0){
                     byteBuf[--byteWriteOffset] = (byte)((numAbs % 10) + ZERO);
                     numAbs /= 10;
                 }
                 if (num<0)
                     byteBuf[--byteWriteOffset] = MINUS;
             }
             os.write(byteBuf, byteWriteOffset, byteBuf.length - byteWriteOffset);
        }
        
        /**
         * Please ensure ar.length <= byteBuf.length!
         * 
         * @param ar
         * @throws IOException
         */
        public void writeByteAr(byte[] ar) throws IOException{
            for (int i = 0; i < ar.length; i++) {
                byteBuf[i] = ar[i];
            }
            os.write(byteBuf,0,ar.length);
        }
        
        public void writeSpaceBar() throws IOException{
            byteBuf[0] = SPACEBAR;
            os.write(byteBuf,0,1);
        }
        
    }
    
    public static class ByteScanner implements Constants{
        
        InputStream is;
        
        public ByteScanner(InputStream is, int bufSizeInput, int bufSize){
            this.is = is;
            this.bufSizeInput = bufSizeInput;
            this.bufSize = bufSize;
            
            byteBufInput = new byte[this.bufSizeInput];
            byteBuf = new byte[this.bufSize];
        }
        
        public ByteScanner(byte[] data){
            byteBufInput = data;
            bufSizeInput = data.length;
            bufSize = data.length;
            byteBuf = new byte[bufSize];
            byteRead = data.length;
            bytePos = 0;
        }
        
        private int bufSizeInput;
        private int bufSize;
        
        byte[] byteBufInput;
        byte by=-1;
        int byteRead=-1;
        int bytePos=-1;

        byte[] byteBuf;
        int totalBytes;
        
        boolean eofMet = false;
        
        private byte nextByte() throws IOException{
            
            if (bytePos<0 || bytePos>=byteRead){
                byteRead = is==null? -1: is.read(byteBufInput);
                bytePos=0;
                if (byteRead<0){
                    byteBufInput[bytePos]=-1;//!!!
                    if (eofMet)
                        throw new EofException();
                    eofMet = true;
                }
            }
            return byteBufInput[bytePos++];
        }
        
        /**
         * Returns next meaningful character as a byte.<br>
         * 
         * @return
         * @throws IOException
         */
        public byte nextChar() throws IOException{
            while ((by=nextByte())<=0x20);
            return by;
        }
        
        /**
         * Returns next meaningful character OR space as a byte.<br>
         * 
         * @return
         * @throws IOException
         */
        public byte nextCharOrSpacebar() throws IOException{
            while ((by=nextByte())<0x20);
            return by;
        }
        
        /**
         * Reads line.
         * 
         * @return
         * @throws IOException
         */
        public String nextLine() throws IOException {
            readToken((byte)0x20);
            return new String(byteBuf,0,totalBytes);
        }
        
        public byte[] nextLineAsArray() throws IOException {
            readToken((byte)0x20);
            byte[] out = new byte[totalBytes];
            System.arraycopy(byteBuf, 0, out, 0, totalBytes);
            return out;
        }
        
        
        /**
         * Reads token. Spacebar is separator char.
         * 
         * @return
         * @throws IOException
         */
        public String nextToken() throws IOException {
            readToken((byte)0x21);
            return new String(byteBuf,0,totalBytes);
        }
        
        /**
         * Spacebar is included as separator char
         * 
         * @throws IOException
         */
        private void readToken() throws IOException {           
            readToken((byte)0x21);
        }
        
        private void readToken(byte acceptFrom) throws IOException {
            totalBytes = 0;
            while ((by=nextByte())<acceptFrom);
            byteBuf[totalBytes++] = by;
            while ((by=nextByte())>=acceptFrom){
                byteBuf[totalBytes++] = by;
            }
        }
        
        public int nextInt() throws IOException{
            readToken();
            int num=0, i=0;
            boolean sign=false;
            if (byteBuf[i]==MINUS){
                sign = true;
                i++;
            }
            for (; i<totalBytes; i++){
                num*=10;
                num+=byteBuf[i]-ZERO;
            }
            return sign?-num:num;
        }
        
        public long nextLong() throws IOException{
            readToken();
            long num=0;
            int i=0;
            boolean sign=false;
            if (byteBuf[i]==MINUS){
                sign = true;
                i++;
            }
            for (; i<totalBytes; i++){
                num*=10;
                num+=byteBuf[i]-ZERO;
            }
            return sign?-num:num;
        }
        
        /*
        //TODO test Unix/Windows formats
        public void toNextLine() throws IOException{
            while ((ch=nextChar())!='\n');
        }
        */
        
        public double nextDouble() throws IOException{
            readToken();
            char[] token = new char[totalBytes];
            for (int i = 0; i < totalBytes; i++) {
                token[i] = (char)byteBuf[i];
            }
            return Double.parseDouble(new String(token));
        }
        
        public int[] loadIntArray(int size) throws IOException{
            int[] a = new int[size];
            for (int i = 0; i < a.length; i++) {
                a[i] = nextInt();
            }
            return a;
        }
        
        public long[] loadLongArray(int size) throws IOException{
            long[] a = new long[size];
            for (int i = 0; i < a.length; i++) {
                a[i] = nextLong();
            }
            return a;
        }
        
    }
    
    
    public static abstract class Timing{
        private static int counter = 0;
        protected String name = "Timing"+(++counter);
        private boolean debug;
        
        public Timing(boolean debug) {
            super();
            this.debug = debug;
        }
        
        public abstract void run();
        public void start(){
            long time1 = System.currentTimeMillis();
            run();
            long time2 = System.currentTimeMillis();
            if (debug)
                System.out.println(name+" time = "+(time2-time1)/1000.0+" ms.");
        }
        
    }
    
    public static class Alg{
        public static interface BooleanChecker{
            public boolean check(long arg);
        }
        
        public static class BinarySearch{
                    
            /**
             * This check returns boolean value, result of function.
             * It should be monotonic.
             * 
             * @return
             */
            public BooleanChecker bc;
            
            
            /**
             * Returns following element: <pre> 0 0 [1] 1 1</pre>
             */
            public long search(long left, long right){
                while (left<=right){
                    long mid = (left+right)/2;
                    if (bc.check(mid)){
                        right = mid-1;
                    }else{
                        left = mid+1;
                    }
                }
                return left;
            }
            
            /**
             * Optional.<br>
             * Returns following element: <pre> 1 1 [1] 0 0</pre>
             */
            public long searchInverted(long left, long right){
                while (left<=right){
                    long mid = (left+right)/2;
                    if (!bc.check(mid)){
                        right = mid-1;
                    }else{
                        left = mid+1;
                    }
                }
                return left - 1; 
            }
        }
    }
    
    public static class Modulo{
        long mod = (long)1e9+7;
        
        public Modulo(long mod) {
            super();
            this.mod = mod;
        }

        public long inv(long a) {
            long res =  pow(a, mod-2);
            return res;
        }

        public long pow(long a, long x) {
            if (x==0)
                return 1;
            long part = 1;
            if ((x&1)!=0)
                part = a;
            return (part * pow((a*a)%mod, x>>1)) % mod;
        }
        
    }
    
    public static void main(String[] args) {
        new R170_B().run();
    }
    
}