#include <bits/stdc++.h>

struct dag_t {
	int n, s, t;
	std::vector<std::vector<int>> adj, rev;
	std::vector<int> ord;
	bool constructed;
	dag_t(int n) : n(n), s(-1), t(-1), constructed(false) {
		adj = std::vector<std::vector<int>>(n, std::vector<int>());
		rev = std::vector<std::vector<int>>(n, std::vector<int>());
	}
	void add_edge(int x, int y) {
		assert(!constructed);
		assert(0 <= x && 0 <= y && x < n && y < n);
		adj[x].push_back(y);
		rev[y].push_back(x);
	}
	bool construct() {
		assert(!constructed);
		constructed = true;
		std::vector<int> deg(adj.size());
		for (int i = 0; i < adj.size(); ++i) {
			deg[i] = adj[i].size();
			if (adj[i].size() == 0) {
				if (t != -1)
					return false;
				t = i;
			}
			if (rev[i].size() == 0) {
				if (s != -1)
					return false;
				s = i;
			}
		}
		if (s == -1 || t == -1)
			return false;
		std::queue<int> que;
		for (int i = 0; i < n; ++i)
			if (!deg[i])
				que.emplace(i);
		while (!que.empty()) {
			int x = que.front(); que.pop();
			ord.push_back(x);
			for (int y : rev[x])
				if (--deg[y] == 0)
					que.emplace(y);
		}
		if (ord.size() != n)
			return false;
		
		return true;
	}
};

const int N = 2050;
const int SIGMA = 26;

void impossible(int message = 0) {
	fprintf(stderr, "message = %d\n", message);
	std::cout << "-1\n";
	exit(0);
}

std::vector<std::pair<int, int>> get_edges(const dag_t &G, bool strict = false){
	std::vector<int> id(G.n, -1), dist(G.n, -1);
	dist[G.t] = 0;
	for (int x : G.ord) {
		if (x == G.t) continue;
		for (int y : G.adj[x])
			dist[x] = std::max(dist[x], dist[y] + 1);
	}
	int tot = 0;
	std::queue<int> que;
	que.emplace(G.s);
	std::vector<std::pair<int, int>> edges;
	while (!que.empty()) {
		int x = que.front(); que.pop();
		std::vector<std::pair<int, int>> sons;
		for (int y : G.adj[x]) {
			dist[x] = std::max(dist[x], dist[y] + 1);
			sons.emplace_back(dist[y], y);
		}
		std::sort(sons.begin(), sons.end());
		for (int i = 0; i + 1 < sons.size(); ++i) {
			if (strict) {
				assert(sons[i].first != sons[i + 1].first);
			}
			else {
				if (sons[i].first == sons[i + 1].first)
					impossible(0);
			}
		}
		for (auto p : sons) {
			int y = p.second;
			if (id[y] == -1) {
				id[y] = ++tot;
				que.emplace(y);
			}
			edges.emplace_back(id[x], id[y]);
		}
	}
	return edges;
}


struct SAM_t {
	int fa[N * 2], ch[N * 2][SIGMA], len[N * 2], tot, lst;
	SAM_t() {
		tot = lst = 1;
	}
	void ins(int x) {
		assert(0 <= x && x < SIGMA);
		int p = lst, np = lst = ++tot;
		len[np] = len[p] + 1;
		while (p && !ch[p][x]) ch[p][x] = np, p = fa[p];
		if (!p) fa[np] = 1;
		else {
			int q = ch[p][x];
			if (len[q] == len[p] + 1)
				fa[np] = q;
			else {
				int nq = ++tot;
				memcpy(ch[nq], ch[q], sizeof ch[q]);
				fa[nq] = fa[q]; len[nq] = len[p] + 1;
				fa[np] = fa[q] = nq;
				while (p && ch[p][x] == q) ch[p][x] = nq, p = fa[p];
			}
		}
	}
	void ins(const std::string &s) {
		for (const char ch : s)
			ins(ch - 'a');
	}
	void clear() {
		for (int i = 0; i <= tot; ++i) {
			fa[i] = len[i] = 0;
			memset(ch[i], 0, sizeof ch[i]);
		}
		tot = lst = 1;
	}
	dag_t get_graph() const {
		dag_t G(tot);
		for (int i = 1; i <= tot; ++i) {
			for (int j = 0; j < SIGMA; ++j) {
				if (ch[i][j] != 0) {
					G.add_edge(i - 1, ch[i][j] - 1);
				}
			}
		}
		G.construct();
		return G;
	}
};

int main() {
	int n, m;
	std::cin >> n >> m;
	dag_t G(n);
	for (int i = 0; i < m; ++i) {
		int x, y;
		std::cin >> x >> y;
		--x, --y;
		G.add_edge(x, y);
	}
	if (!G.construct()) {
		impossible(1);
	}
	SAM_t sam;
	std::string s;
	auto vG = get_edges(G);
	int len = -1;
	std::string ret = std::string(1, 127);
	auto solve = [&]() {
		std::vector<std::vector<int>> path(G.n);
		path[G.t] = {0};
		for (int x : G.ord) {
			if (x == G.t) continue;
			for (int y : G.adj[x]) {
				for (int c : path[y])
					path[x].push_back(c + 1);
			}
			if (path[x].size() > n)
				impossible(2);
			std::sort(path[x].begin(), path[x].end());
		}
		std::sort(path[G.s].begin(), path[G.s].end());
		path[G.s].erase(std::unique(path[G.s].begin(), path[G.s].end()), path[G.s].end());
		int min = *std::min_element(path[G.s].begin(), path[G.s].end());
		int max = *std::max_element(path[G.s].begin(), path[G.s].end());
		if (path[G.s].size() != max - min + 1)
			impossible(3);
		s = std::string(max, -1);
		std::vector<int> vis(G.n, -1), to(G.n);
		for (int y : G.adj[G.s])
			for (int z : path[y])
				to[z + 1] = y;
		int k = max - min, c = 0; 
		len = max;
		for (int i = 0; i <= max - min; ++i) {
			if (vis[to[max - i]] == -1) {
				vis[to[max - i]] = c++;
			}
			s[i] = vis[to[max - i]] + 'a';
		}
		for (int t = 0; t + min - 1 < s.length(); ++t) {
			std::string ns = s;
			for (int i = 0; i < min - 1; ++i)
				ns[max - min + 1 + i] = ns[t + i];
			for (char ch : ns) assert(ch != -1);
			sam.clear();
			sam.ins(ns);
			auto H = sam.get_graph();
			auto vH = get_edges(H, true);
			if (G.n == H.n && vG == vH) {
				ret = std::min(ret, ns);
			}
		}
	};
	solve();
	if (ret == std::string(1, 127))
		impossible(5);
	std::cout << ret << '\n';
	return 0;
}