
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <cstring>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <list>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <unordered_set>
#include <unordered_map>
#include <array>
#include <cassert>
#include <bitset>
using namespace std;
using LL = long long;

//??\?°??????????????§??????????(SA)
//???????????????????????§?????????(LCP)
//LCP????????°??¨?????¶??£????????¨?????????????????¨?????????????????????
//??????????????°???str.substr(a,b)??§[a,a+b)(??????????????¨b=???)
//str.compare(a,b,T)??§substr(a,b)??¨T???????????????str<T:-,str==T:0,str>T:+????????????????????????
struct SuffixArray {
	int n;
	string str;
	//sa[k]:=?????????[k,n)??????????????§???????????????
	vector<int>sa, lcp;
	//?????????s?????\?°??????????????§?????????? O(n log n)
	SuffixArray(string s) :str(s), n(s.size()) {
		sa.resize(n + 1);
		vector<int>rank(n + 1);
		for (int i = 0; i <= n; ++i) {
			sa[i] = i;
			rank[i] = (i < n) ? str[i] : -1;
		}
		vector<int>tmp(n + 1);
		for (int k = 1; k <= n; k *= 2) {
			auto comp = [&](int i, int j) {
				if (rank[i] != rank[j])
					return rank[i] < rank[j];
				else {
					int ri = i + k <= n ? rank[i + k] : -1;
					int rj = j + k <= n ? rank[j + k] : -1;
					return ri < rj;
				}
			};
			sort(sa.begin(), sa.end(), comp);
			tmp[sa[0]] = 0;
			for (int i = 1; i <= n; ++i)
				tmp[sa[i]] = tmp[sa[i - 1]] + (comp(sa[i - 1], sa[i]) ? 1 : 0);
			rank = tmp;
		}
		//????????????LCP?§????
		lcp.resize(n);
		for (int i = 0; i < n; ++i)rank[sa[i]] = i;
		int h = 0;
		lcp[0] = 0;
		for (int i = 0; i < n; ++i) {
			int j = sa[rank[i] - 1];
			if (h > 0)--h;
			for (; j + h < n&&i + h < n; ++h)
				if (str[j + h] != str[i + h])break;
			lcp[rank[i] - 1] = h;
		}
	}
	//?????????T??\??????????°??????\?°??????????????????????????????????
	int lower_bound(const string& T) {
		int lo = -1, hi = n + 1;
		while (lo + 1 < hi) {
			int mid = (lo + hi) / 2;
			/*
			int si = sa[mid], ti = 0;
			bool flag = false, res = false;
			while (si < n && ti < T.size()) {
				if (str[si] < T[ti]) {
					flag = true; res = true; break;
				}
				if (str[si] > T[ti]) {
					flag = true; res = false; break;
				}
				++si; ++ti;
			}
			if (!flag)res = (si >= n && ti < T.size());
			if (res) lo = mid;
			else hi = mid;
			*/
			if (str.compare(sa[mid], T.size(), T) < 0) {
				lo = mid;
			}
			else {
				hi = mid;
			}
		}
		return hi;
	}
	//?????????T????????§??????????°??????\?°??????????????????????????????????
	//????????????????????¢???????????¢
	int upper_bound(string T) {
		assert(T.size());
		T.back()++;
		int res = lower_bound(T);
		T.back()--;
		return res;
	}
	//????????????????????????????????????T????????°???????????????
	//|T| log |S|
	int contain(const string& T) {
		return upper_bound(T) - lower_bound(T);
	}
};


int main(void)
{
	int N;
	string s;
	cin >> N;
	for (int i = 0; i < N; ++i) {
		string t;
		cin >> t;
		s.append(t);
		s.push_back('$');
	}
	SuffixArray sa(s);
	for (int k = 1; k <= s.size(); ++k) {
		string t(k, 'a');
		for (;;) {
			if (!sa.contain(t)) {
				cout << t << endl;
				return 0;
			}
			t.back()++;
			bool flag = true;
			for (int i = k - 1; i >= 0; --i) {
				if (t[i] > 'z') {
					t[i] = 'a';
					if (i == 0) {
						flag = false;
						break;
					}
					t[i - 1]++;
				}
			}
			if (!flag)break;
		}
	}
	return 0;
}