You are solving the crossword problem K from IPSC 2014. You solved all the clues except for one: who does Eevee evolve into? You are not very into pokemons, but quick googling helped you find out, that Eevee can evolve into eight different pokemons: Vaporeon, Jolteon, Flareon, Espeon, Umbreon, Leafeon, Glaceon, and Sylveon.

You know the length of the word in the crossword, and you already know some letters. Designers of the crossword made sure that the answer is unambiguous, so you can assume that exactly one pokemon out of the 8 that Eevee evolves into fits the length and the letters given. Your task is to find it.


-----Input-----

First line contains an integer n (6 ≤ n ≤ 8) – the length of the string.

Next line contains a string consisting of n characters, each of which is either a lower case english letter (indicating a known letter) or a dot character (indicating an empty cell in the crossword).


-----Output-----

Print a name of the pokemon that Eevee can evolve into that matches the pattern in the input. Use lower case letters only to print the name (in particular, do not capitalize the first letter).


-----Examples-----
Input
7
j......

Output
jolteon

Input
7
...feon

Output
leafeon

Input
7
.l.r.o.

Output
flareon



-----Note-----

Here's a set of names in a form you can paste into your solution:

["vaporeon", "jolteon", "flareon", "espeon", "umbreon", "leafeon", "glaceon", "sylveon"]

{"vaporeon", "jolteon", "flareon", "espeon", "umbreon", "leafeon", "glaceon", "sylveon"}

Difficulty: EASY

Solutions:
import re
n = input()
print(next(filter(re.compile(input() + '$').match, ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon'])))


import re
evolutions = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
inplen = int(input())
inp = input().strip()
for evolution in evolutions:
	if re.match(inp, evolution) and inplen == len(evolution):
		print(evolution)
		break


import re
L = int(input())
P = re.compile('^' + input() + '$')
S = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for i in S:
	if P.match(i):
		print(i)


def get_key(d, value):
	for (k, v) in d.items():
		if v == value:
			return k
n = int(input())
s = input()
d = {0: 'vaporeon', 1: 'jolteon', 2: 'flareon', 3: 'espeon', 4: 'umbreon', 5: 'leafeon', 6: 'glaceon', 7: 'sylveon'}
d1 = {}
for i in d:
	if len(d[i]) != len(s):
		continue
	else:
		q = d[i]
		k = 0
		for j in range(0, n):
			if q[j] == s[j]:
				k += 1
		d1[d[i]] = k
p = max(d1.values())
print(get_key(d1, p))


names = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
l = input()
n = input()
for name in names:
	if len(name) != len(n):
		continue
	ok = True
	for i in range(len(name)):
		if n[i] == '.':
			continue
		if n[i] != name[i]:
			ok = False
	if ok:
		print(name)
		break


import re
length = int(input())
word = input()
regex = re.compile(word)
evolutions = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for i in evolutions:
	ans = regex.fullmatch(i)
	if ans:
		print(ans.group())
		break


import re
n = int(input())
m = re.compile(input())
gueses = []
evolves = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for x in evolves:
	if m.match(x):
		gueses.append(x)
for x in gueses:
	if len(x) == n:
		print(x)


def evolve(l):
	for e in ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']:
		if len(e) == len(l):
			yes = 1
			for x in range(min(len(l), len(e))):
				if l[x] != '.':
					if l[x] != e[x]:
						yes = 0
			if yes == 1:
				return e
	return 0
i = int(input())
l = list(input())
print(evolve(l))


note = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
daf = input()
note = [x for x in note if len(x) == n]
for x in note:
	for i in range(min(n, len(x))):
		if daf[i] != '.':
			if daf[i] != x[i]:
				break
	else:
		print(x)
		break


import re
arr = 'Vaporeon, Jolteon, Flareon, Espeon, Umbreon, Leafeon, Glaceon, Sylveon'.split(', ')
n = int(input())
s = input()
s = s.replace('.', '(.*)')
for i in range(len(arr)):
	arr[i] = arr[i].lower()
for i in arr:
	if re.match(s, i) and len(i) == n:
		print(i)
		break


n = int(input())
s = input()
data = {8: ['vaporeon'], 7: ['jolteon', 'glaceon', 'flareon', 'umbreon', 'leafeon', 'sylveon'], 6: ['espeon']}
for i in range(len(data[n])):
	t = True
	for j in range(len(data[n][i])):
		if s[j] != '.' and s[j] != data[n][i][j]:
			t = False
			break
	if t:
		print(data[n][i])


n = int(input())
j = input()
num = -1
evo = {'vaporeon': 0, 'jolteon': 0, 'flareon': 0, 'espeon': 0, 'umbreon': 0, 'leafeon': 0, 'glaceon': 0, 'sylveon': 0}
for i in evo:
	if len(j) == len(i):
		p = -1
		for m in i:
			p = p + 1
			if m == j[p]:
				evo[i] = evo[i] + 1
	else:
		evo[i] = -1
nmax = 'vaporeon'
for i in evo:
	if evo[i] > evo[nmax]:
		nmax = i
print(nmax)


__author__ = 'Gleb'
var = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
s = input()
for i in range(8):
	if n == len(var[i]):
		flag = 0
		for j in range(n):
			if not s[j] == '.':
				if s[j] == var[i][j]:
					flag += 1
			else:
				flag += 1
		if flag == n:
			print(var[i])


n = int(input())
k = ['vaporeon']
six = ['espeon']
sev = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
s = input().strip()
if n == 6:
	print(*six)
elif n == 8:
	print(*k)
else:
	p = False
	z = []
	for x in range(n):
		if s[x] != '.':
			z.append((s[x], x))
	for x in sev:
		for (m, n) in z:
			if x[n] != m:
				break
		else:
			print(x)
			p = True
		if p == True:
			break


import re
E = 'eon'
l = ['vapor', 'jolt', 'flar', 'esp', 'umbr', 'leaf', 'glac', 'sylv']
input()
p = input()
print(next((s + E for s in l if re.fullmatch(p, s + E))))


n = int(input())
s = input()
evol = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for e in evol:
	if len(e) != n:
		continue
	for i in range(n):
		if s[i] != e[i] and s[i] != '.':
			break
	if i == n - 1:
		print(e)
		break


from re import match
input()
s = input().strip()
for x in ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']:
	if match('^' + s + '$', x):
		print(x)
		return


def main():
	n = int(input())
	s = input()
	d = {}
	if n == 6:
		print('espeon')
	elif n == 8:
		print('vaporeon')
	else:
		for i in range(len(s)):
			if s[i] != '.':
				d[i] = s[i]
		print(find(d))
l = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']

def find(d):
	k = 0
	for j in range(len(l)):
		for i in d.keys():
			if l[k][i] != d[i]:
				l.remove(l[k])
				break
		else:
			k = 1
	return l[0]
main()


import re
input()
print(next(filter(re.compile(input()[:-3] + '$').match, ['vapor', 'jolt', 'flar', 'esp', 'umbr', 'leaf', 'glac', 'sylv'])) + 'eon')


n = int(input())
clue = str(input())
namelist = ['jolt', 'flar', 'umbr', 'leaf', 'glac', 'sylv']
notname = []
if n == 8:
	print('vaporeon')
	quit()
if n == 6:
	print('espeon')
	quit()
clue = clue[:-3]
for i in range(4):
	for name in namelist:
		if name not in notname:
			if clue[i] != '.' and clue[i] != name[i]:
				notname.append(name)
for name in namelist:
	if name not in notname:
		print(name + 'eon')
		quit()


def match(s, p):
	if len(s) != len(p):
		return False
	for (chs, chp) in zip(s, p):
		if chs != '.' and chs != chp:
			return False
	return True
n = int(input())
s = input()
for p in ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']:
	if match(s, p):
		print(p)


def match(p, s):
	return len(p) == len(s) and all((d in ('.', c) for (d, c) in zip(p, s)))
l = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
input()
p = input()
print(next((s for s in l if match(p, s))))


n = int(input())
n1 = input()
lst = []
b = 0
v = 0
s = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for i in s:
	b = 0
	for j in range(len(n1) - 1):
		if n1[j] == '.':
			continue
		elif n1[j] != i[j]:
			b = b + 1
	if b == 0 and len(n1) == len(i):
		lst.append(i)
print(lst[0])


pokemon = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
palabra = input()
mayor = 0
if n == 7:
	for j in range(6):
		cnt = 0
		for i in range(n):
			if palabra[i] == pokemon[j][i]:
				cnt += 1
		if cnt > mayor:
			mayor = cnt
			b = j
	print(pokemon[b])
if n == 6:
	print('espeon')
elif n == 8:
	print('vaporeon')


def __starting_point():
	names = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
	N = int(input())
	nm = input()
	for x in names:
		if len(x) == N:
			st = True
			for i in range(N):
				if nm[i] != '.' and nm[i] != x[i]:
					st = False
			if st:
				print(x)
				break
__starting_point()


error_intro = '\nRuntime ERROR: '
n = int(input())
string = input()
names = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
if 6 <= n <= 8:
	if n == len(string):
		for name in names:
			if len(name) == n:
				match = 0
				for l in range(0, n):
					if name[l] == string[l] or string[l] == '.':
						match = match + 1
				if match == n:
					print(name)
	else:
		print(error_intro + 'len(string) != n')
elif 6 > n:
	print(error_intro + "value of 'n' is too low")
else:
	print(error_intro + "value of 'n' is too high")


import re
n = int(input())
str = input()
str = str.replace('.', '\\D')
pattern = re.compile('^' + str + '$')
for s in {'vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon'}:
	if pattern.search(s):
		print(s)
		break


n = int(input())
s = input()
list = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
i = 0
while i < 8:
	if len(list[i]) == n:
		j = 0
		while j < n:
			if s[j] != '.' and s[j] != list[i][j]:
				break
			j += 1
		if j == n:
			print(list[i])
			exit()
	i += 1


n = int(input())
s = str(input())
l = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for e in l:
	if len(e) == len(s) and all((s[i] == '.' or s[i] == e[i] for i in range(n))):
		print(e)
		exit()


a = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = input()
s = input()
res = ''
for k in a:
	if len(k) == len(s):
		cnt = 0
		for i in range(len(s)):
			if k[i] == s[i] or s[i] == '.':
				cnt += 1
		if cnt == len(s):
			print(k)


n = input()
if n == '8':
	print('vaporeon')
	exit()
elif n == '6':
	print('espeon')
	exit()
k = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
s = input()
for p in k:
	for i in range(7):
		if s[i] != '.' and s[i] != p[i]:
			break
		if i == 5:
			print(p)
			exit()


from typing import List
n: int = int(input())
string: str = input()
pokemons: List[str] = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
_string: str = ''.join(map(lambda x: '' if x == '.' else x, string))
_nstring = len(_string)

def matchPokemons(string: str=string, pokemons: List[str]=pokemons) -> str:
	isTrue: bool = True
	for pokemon in pokemons:
		count: int = 0
		if len(pokemon) == n:
			for i in range(n):
				if string[i] == pokemon[i]:
					count = count + 1
			if count == _nstring:
				return pokemon
print(matchPokemons(string, pokemons))


import re
strLen = int(input())
name = input()
names = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for n in names:
	if re.search(name, n) and len(n) == strLen:
		print(n)
		break


pokemon = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
length = int(input())
unknown_name = input()
for current_pokemon in pokemon:
	if len(current_pokemon) != length:
		continue
	for (i, c) in enumerate(unknown_name):
		if c == '.':
			continue
		if current_pokemon[i] != c:
			break
	else:
		print(current_pokemon)


import sys
x = int(sys.stdin.readline())
a = sys.stdin.readline()
mp = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
found = False
st = ''
for m in range(len(mp)):
	if len(mp[m]) == len(a) - 1:
		ok = True
		for i in range(len(a) - 1):
			if a[i] is '.':
				continue
			if a[i] != mp[m][i]:
				ok = False
				break
		if ok is True:
			st = mp[m]
			found = True
	if found is True:
		break
print(st)


pokemons = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
maskedPM = input()
for p in pokemons:
	if n == len(p):
		isValid = True
		for i in range(n):
			if maskedPM[i] != '.':
				if maskedPM[i] != p[i]:
					isValid = False
		if isValid:
			print(p)
			break


names = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
xx = input()
for name in names:
	if n != len(name):
		continue
	good = True
	for i in range(len(name)):
		if not xx[i] in ['.', name[i]]:
			good = False
	if good:
		print(name)


names = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
s = input()
for name in names:
	flag = len(name) == len(s)
	if flag:
		for i in range(len(s)):
			if s[i] != '.' and s[i] != name[i]:
				flag = False
	if flag:
		print(name)
		break


n = int(input())
string = input()
choose = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
list = []
if n == 8:
	print('vaporeon')
elif n == 6:
	print('espeon')
elif n == 7:
	for i in choose:
		k = 0
		for j in range(7):
			if string[j] == '.':
				pass
			elif i[j] != string[j]:
				k = 1
				break
		if k == 0:
			list.append(i)
for i in list:
	print(i)


import re

def main():
	input()
	p = re.compile(input())
	pokemons = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
	pokemons = sorted(pokemons, key=len)
	for x in pokemons:
		if p.match(x):
			print(x)
			break
main()


n = int(input())
s = input()
a = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
x = 0
for i in range(8):
	if len(s) == len(a[i]):
		for j in range(len(s)):
			if s[j] != '.' and s[j] != a[i][j]:
				x = 1
				break
		if x:
			x = 0
		else:
			print(a[i])
			break


l6 = 'espeon'
l7 = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
l8 = 'vaporeon'
n = int(input())
psw = input()
if n == 6:
	print(l6)
elif n == 8:
	print(l8)
else:
	for s in l7:
		ans = 1
		for i in range(7):
			if s[i] != psw[i] and psw[i] != '.':
				ans = 0
				break
		if ans == 1:
			print(s)
			break


def match(s, t):
	if len(s) != len(t):
		return False
	return all((x == y or x == '.' for (x, y) in zip(s, t)))
input()
pat = input()
a = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for n in a:
	if match(pat, n):
		print(n)
		break


n = int(input())
s = input()
listOfWords = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
i = 0
while i < n:
	for poke in reversed(listOfWords):
		if len(poke) != n or (s[i] != '.' and s[i] != poke[i]):
			listOfWords.remove(poke)
	if len(listOfWords) == 1:
		break
	i += 1
print(listOfWords[0])


n = int(input())
text = input()
data = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
count_answer = [0, 0, 0, 0, 0, 0, 0, 0]
for index_letter in range(len(text)):
	if text[index_letter] == '.':
		continue
	else:
		for word in range(len(data)):
			if len(data[word]) != n:
				continue
			if text[index_letter] == data[word][index_letter]:
				count_answer[word] += 1
max_num = max(count_answer)
if max_num == 0:
	for item in data:
		if len(item) == n:
			print(item)
			break
else:
	solve = count_answer.index(max_num)
	print(data[solve])


import sys

def get_single_int():
	return int(sys.stdin.readline().strip())

def get_string():
	return sys.stdin.readline().strip()

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))

def unique(n):
	if n == 8:
		print('vaporeon')
	else:
		print('espeon')

def same(names):
	for j in names:
		if j[i] != s[i]:
			try:
				names_copy.remove(j)
			except:
				continue
n = get_single_int()
s = get_string()
names = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
names_copy = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
if n == 6 or n == 8:
	unique(n)
else:
	for i in range(7):
		if s[i] == '.':
			continue
		else:
			same(names)
	print(names_copy[0])


import re
length = int(input())
sample = input()
reg_search = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for element in reg_search:
	if len(element) == length and re.search(sample, element):
		print(element)


n = int(input())
s = input()
a = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
b = [0] * len(a)
for name in a:
	if len(name) == n:
		for i in range(len(name)):
			if s[i] == name[i]:
				b[a.index(name)] += 1
imaior = -1
maior = -1
for i in range(len(a)):
	if b[i] > maior and len(a[i]) == n:
		imaior = i
		maior = b[i]
print(a[imaior])


from collections import deque, defaultdict, Counter
from itertools import product, groupby, permutations, combinations
from math import gcd, floor, inf
from bisect import bisect_right, bisect_left
names = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']

def equal(word1, word2):
	if len(word1) != len(word2):
		return False
	for (char1, char2) in zip(word1, word2):
		if char1.isalnum() and char2.isalnum() and (char2 != char1):
			return False
	return True
num = int(input())
s = input()
for word in names:
	if equal(word, s):
		print(word)
		break


import sys
import math
n = int(sys.stdin.readline())
instr = sys.stdin.readline()
var = [['espeon'], ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon'], ['vaporeon']]
vmax = 0
res = var[n - 6][0]
for k in var[n - 6]:
	t = 0
	for i in range(n):
		if instr[i] == k[i]:
			t += 1
	if t > vmax:
		vmax = t
		t = 0
		res = k
print(res)


n = int(input())
s = input()
if n == 6:
	print('espeon')
elif n == 8:
	print('vaporeon')
else:
	l = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
	for i in range(6):
		z = 0
		for j in range(7):
			if s[j] != '.' and s[j] != l[i][j]:
				z = -1
				break
		if z == 0:
			print(l[i])


l_n = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
s = input()
l_n = [x for x in l_n if len(x) == n]
for x in l_n:
	for i in range(len(s)):
		if s[i] != '.' and s[i] != x[i]:
			break
		elif i + 1 == len(s):
			print(x)
			quit()


choices = 'Vaporeon, Jolteon, Flareon, Espeon, Umbreon, Leafeon, Glaceon'.split(', ')
choices.append('Sylveon')
choices = list(map(lambda x: x.lower(), choices))
n = int(input())
s = input()
for can in choices:
	if n != len(can):
		continue
	isValid = True
	for i in range(n):
		if s[i] != '.' and s[i] != can[i]:
			isValid = False
	if isValid:
		print(can)
		break


l = int(input())
st = input()
se = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
se = [c[:4] for c in se if len(c) == 7]
sus = ''
if l == 6:
	print('espeon')
elif l == 8:
	print('vaporeon')
else:
	st = st[:4]
	for suspect in se:
		match = True
		for i in range(0, len(st)):
			ch = st[i]
			if ch == '.':
				continue
			elif suspect[i] != ch:
				match = False
				break
		if match:
			sus = suspect
			break
	print(sus + 'eon')


import re
sa = int(input())
sa2 = input()
names = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
if len(sa2) == 6:
	print('espeon')
elif len(sa2) == 8:
	print('vaporeon')
else:
	for sasa in names:
		if re.match(sa2, sasa, re.I):
			print(sasa)


import math

def main_function():
	pokemons = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
	n = int(input())
	s = input()
	pokemon_is_found = False
	for pokemon in pokemons:
		if len(pokemon) != len(s):
			continue
		for i in range(len(pokemon)):
			if s[i] != '.':
				if s[i] != pokemon[i]:
					break
			if i == len(pokemon) - 1:
				pokemon_is_found = True
				print(pokemon)
				break
		if pokemon_is_found:
			break
main_function()


poks = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
length = input()
unknown = input()
lis = list(unknown)
lisPossible = []
for pokie in poks:
	if len(lis) == len(pokie):
		lisPossible.append(pokie)
ctr = 0
for char in lis:
	lisRemove = []
	if char == '.':
		ctr += 1
		continue
	for pokie in lisPossible:
		if not char == pokie[ctr]:
			lisRemove.append(pokie)
	for poke in lisRemove:
		if poke in lisPossible:
			lisPossible.remove(poke)
	ctr += 1
print(lisPossible[0])


t = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
p = input()
for i in t:
	if n == len(i) and all((i[j] == p[j] for j in range(n) if p[j] != '.')):
		print(i)
		break


P = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
Check = [True] * 8
(N, X) = (int(input()), input())
for i in range(N):
	if X[i] != '.':
		for j in range(len(P)):
			if len(P[j]) != N or X[i] != P[j][i]:
				Check[j] = False
for i in range(8):
	if len(P[i]) == N and Check[i]:
		print(P[i])
		exit()


pokemons = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
s = input()
if n == 6:
	print('espeon')
else:
	for pokemon in pokemons:
		oppor = True
		for i in range(len(s)):
			if len(s) == len(pokemon) and s[i] != '.' and (s[i] != pokemon[i]):
				oppor = False
		if len(s) == len(pokemon) and oppor:
			print(pokemon)
			break


arr = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
s = input()
maxmatch = -1
ans = ''
for i in range(len(arr)):
	matches = 0
	for j in range(len(s)):
		if s[j] != '.':
			if j < len(arr[i]) and arr[i][j] == s[j]:
				matches = matches + 1
	if matches > maxmatch and len(arr[i]) == len(s):
		maxmatch = matches
		ans = arr[i]
print(ans)


a = int(input())
pokemao = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
s = input()
for i in range(8):
	flag = True
	for j in range(len(s)):
		if len(pokemao[i]) != len(s) or (s[j] != pokemao[i][j] and s[j] != '.'):
			flag = False
	if flag == True:
		print(pokemao[i])
		break


import re
p = ['espeon', 'jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon', 'vaporeon']
fodac = input()
s = input()
ans = [i for i in p if re.search(s, i)]
print(ans[0])


import re
n = map(int, input())
w = input()
l = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for x in l:
	if len(x) == len(w) and re.match('^' + w, x):
		print(x)


se = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
input()
s = input()
for i in se:
	if len(i) == len(s):
		res = False
		for j in range(len(s)):
			if s[j] != i[j] and s[j] != '.':
				res = True
		if not res:
			print(i)


n = int(input())
if n == 8:
	print('vaporeon')
elif n == 6:
	print('espeon')
else:
	l = {'Jolteon', 'Flareon', 'Umbreon', 'Leafeon', 'Glaceon', 'Sylveon'}
	ans = set()
	s = input().capitalize()
	for i in range(n):
		if s[i] != '.':
			for j in l:
				if s[i] == j[i]:
					ans.add(j)
			if ans:
				l = l.intersection(ans)
				ans = set()
	if len(l) == 1:
		for i in l:
			print(i.lower())


import sys
a = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
s = input()
for i in a:
	if len(i) == n:
		ss = 0
		for x in range(n):
			if s[x] == i[x]:
				ss += 1
		if ss == n - s.count('.'):
			print(i)


import re
input()
print(next(filter(re.compile(input() + '$').match, [x + 'eon' for x in ['vapor', 'jolt', 'flar', 'esp', 'umbr', 'leaf', 'glac', 'sylv']])))


def match(p, s):
	if len(p) != len(s):
		return False
	for (d, c) in zip(p, s):
		if d not in ('.', c):
			return False
	return True
l = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
input()
p = input()
print(next((x for x in l if match(p, x))))


def is_match(s, name):
	for i in range(len(s)):
		if not (s[i] == '.' or s[i] == name[i]):
			return False
	return True
n = int(input())
s = input()
names = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
if n == 8:
	print('vaporeon')
elif n == 6:
	print('espeon')
else:
	for name in names:
		if is_match(s, name):
			print(name)


import re
length = int(input())
eeveEvos = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
eeveEvo = input()
evoRegex = re.compile(eeveEvo)
for evo in eeveEvos:
	if len(evo) == length:
		if evoRegex.match(evo):
			print(evo)
			break


import re
n = int(input())
pattern = input()
names = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
possibles = list(filter(lambda x: len(x) == n, names))
for s in possibles:
	if re.match(pattern, s):
		print(s)
		break


n = int(input())
s = input()
a = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for i in a:
	if len(i) != len(s):
		continue
	b = True
	for j in range(len(s)):
		if s[j] != '.' and i[j] != '.' and (s[j] != i[j]):
			b = False
	if b:
		print(i)
		exit(0)


S = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
s = input()
for x in S:
	if len(x) == n:
		for (a, b) in zip(x, s):
			if b != '.' and a != b:
				break
		else:
			print(x)
			break


b = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
a = input()
c = 0
b = [x for x in b if len(x) == n]
for word in b:
	for x in range(n):
		if a[x] == '.':
			continue
		elif a[x] != word[x]:
			break
	if x + 1 == n:
		print(word)


import re
input()
s = '^' + input() + '$'
for p in ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']:
	if re.match(s, p):
		print(p)
		break


n = int(input().strip())
p = input().strip()
if n == 8:
	print('vaporeon')
elif n == 6:
	print('espeon')
else:
	pokes = set(['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon'])
	for i in range(n):
		rem = set()
		if p[i] != '.':
			for l in pokes:
				if l[i] != p[i]:
					rem.add(l)
			pokes = pokes - rem
			if len(pokes) == 1:
				for x in pokes:
					print(x)
				break


n = int(input())
s = input()
if n == 8:
	print('vaporeon')
	quit()
elif n == 6:
	print('espeon')
	quit()
a = [0, 'jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
c1 = 0
c2 = 0
c3 = 0
c4 = 0
c5 = 0
c6 = 0
for x in zip(s, a[1]):
	if x[0] == x[1]:
		c1 += 1
for x in zip(s, a[2]):
	if x[0] == x[1]:
		c2 += 1
for x in zip(s, a[3]):
	if x[0] == x[1]:
		c3 += 1
for x in zip(s, a[4]):
	if x[0] == x[1]:
		c4 += 1
for x in zip(s, a[5]):
	if x[0] == x[1]:
		c5 += 1
for x in zip(s, a[6]):
	if x[0] == x[1]:
		c6 += 1
if c1 > c2 and c1 > c3 and (c1 > c4) and (c1 > c5) and (c1 > c6):
	print(a[1])
elif c2 > c1 and c2 > c3 and (c2 > c4) and (c2 > c5) and (c2 > c6):
	print(a[2])
elif c3 > c2 and c3 > c1 and (c3 > c4) and (c3 > c5) and (c3 > c6):
	print(a[3])
elif c4 > c2 and c4 > c3 and (c4 > c1) and (c4 > c5) and (c4 > c6):
	print(a[4])
elif c5 > c2 and c5 > c3 and (c5 > c4) and (c5 > c1) and (c5 > c6):
	print(a[5])
elif c6 > c2 and c6 > c3 and (c6 > c4) and (c6 > c5) and (c6 > c1):
	print(a[6])


n = int(input())
s = input()
l = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
if n == 6:
	print('espeon')
elif n == 8:
	print('vaporeon')
else:
	for x in l:
		for i in range(n):
			if s[i] != '.' and s[i] != x[i]:
				break
		else:
			print(x)


def main():
	(n, s) = (int(input()), input())
	poks = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
	for word in [x for x in poks if len(x) == n]:
		res = list(s)
		for i in range(n):
			if res[i] == '.':
				res[i] = word[i]
		if ''.join(res) in poks:
			return ''.join(res)
print(main())


S = set(['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon'])
n = int(input())
St = input()
for s in S:
	if len(St) != len(s):
		continue
	f = 1
	for (i, v) in enumerate(St):
		if v != '.' and v != s[i]:
			f = 0
			break
	if f == 1:
		print(s)
		break


import re
pokemons = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
int(input())
pattern = input()
if len(pattern) == 6:
	print('espeon')
elif len(pattern) == 8:
	print('vaporeon')
else:
	for word in pokemons:
		if re.match(pattern, word):
			print(word)


import re
t = int(input())
pat = input()
pat = '^' + pat + '$'
if re.match(pat, 'vaporeon', re.M | re.I):
	print('vaporeon')
elif re.match(pat, 'jolteon', re.M | re.I):
	print('jolteon')
elif re.match(pat, 'flareon', re.M | re.I):
	print('flareon')
elif re.match(pat, 'espeon', re.M | re.I):
	print('espeon')
elif re.match(pat, 'umbreon', re.M | re.I):
	print('umbreon')
elif re.match(pat, 'leafeon', re.M | re.I):
	print('leafeon')
elif re.match(pat, 'glaceon', re.M | re.I):
	print('glaceon')
elif re.match(pat, 'sylveon', re.M | re.I):
	print('sylveon')


n = int(input())
t = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
b = input()
s = []
for j in range(n):
	if b[j] != '.':
		s.append([j, b[j]])
if len(s) == 0:
	for i in t:
		if len(i) == len(b):
			print(i)
			break
else:
	for i in t:
		c = 0
		for v in s:
			if v[0] <= len(i) - 1:
				if i[v[0]] == v[1]:
					pass
				else:
					c += 1
			else:
				break
		if c == 0 and n == len(i):
			print(i)
			break


import sys
from math import *

def solve():
	n = input()
	s = input()
	a = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
	(x, y) = (-1, 0)
	for aa in a:
		k = 0
		if len(aa) == len(s):
			for i in range(len(aa)):
				if aa[i] == s[i]:
					k += 1
		else:
			continue
		if k > x:
			x = k
			y = aa
	print(y)
solve()


evols = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']

def agree(s, t):
	if len(s) != len(t):
		return False
	else:
		return all([s[i] == '.' or s[i] == t[i] for i in range(len(s))])
n = int(input())
s = input()
ans = None
for evol in evols:
	if agree(s, evol):
		ans = evol
print(ans)


import sys
n = int(sys.stdin.readline())
pokemon = sys.stdin.readline().strip()
pokemons = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']

def whatPokemon(pokemon, pokemons):
	for name_pokemon in pokemons:
		if len(name_pokemon) == len(pokemon):
			goodPokemon = True
			for pos in range(len(pokemon)):
				if pokemon[pos] != '.':
					if pokemon[pos] != name_pokemon[pos]:
						goodPokemon = False
						break
			if goodPokemon:
				return name_pokemon
print(whatPokemon(pokemon, pokemons))


import re
a = 'vaporeon, jolteon, flareon, espeon, umbreon, leafeon, glaceon, sylveon'
a = a.split(', ')
n = int(input())
s = input()
for pokemon in a:
	if re.search('^' + s + '$', pokemon):
		print(pokemon)


n = int(input())
s = input()
l = [i for i in ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon'] if len(i) == n]
for x in l:
	for y in range(n):
		if all((s[y] == x[y] for y in range(n) if s[y] != '.')):
			print(x)
			break


import sys
import math
import itertools
import collections

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=1):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	newnumber = 0
	while number > 0:
		newnumber += number % base
		number //= base
	return newnumber

def cdiv(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def wr(arr):
	return '\n'.join(map(str, arr))

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)
p = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = ii()
s = input()
for pokemon in p:
	c = 0
	if len(pokemon) != n:
		continue
	else:
		for i in range(n):
			if s[i] != '.' and s[i] == pokemon[i]:
				c += 1
		if c == len(s) - s.count('.'):
			exit(print(pokemon))


import re
n = int(input())
regexp = re.compile(input())
for i in ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']:
	match = regexp.match(i)
	if match and match.group(0) == i:
		print(i)


arr = [[8, 'vaporeon'], [7, 'jolteon'], [7, 'flareon'], [6, 'espeon'], [7, 'umbreon'], [7, 'leafeon'], [7, 'glaceon'], [7, 'sylveon']]

def func(s, n):
	for (i, k) in arr:
		flag = True
		if n == i:
			for j in range(n):
				if s[j] != '.':
					if s[j] != k[j]:
						flag = False
						break
			if flag:
				return k
n = int(input())
s = input()
print(func(s, n))


evolucion = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
longitud = int(input())
palabra = input()
if longitud == 8:
	print('vaporeon')
elif longitud == 6:
	print('espeon')
else:
	indices = []
	for i in range(longitud):
		if palabra[i] != '.':
			indices.append(i)
	respuesta = None
	i = 0
	while i < 8 and respuesta is None:
		es_la_palabra = True
		for j in range(len(indices)):
			es_la_palabra = es_la_palabra and palabra[indices[j]] == evolucion[i][indices[j]]
		if es_la_palabra:
			respuesta = evolucion[i]
		i = i + 1
	print(respuesta)


a = int(input())
if a == 8:
	print('vaporeon')
elif a == 6:
	print('espeon')
else:
	b = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
	c = input()
	for i in b:
		d = True
		for j in range(7):
			if c[j] == '.':
				continue
			if c[j] != i[j]:
				d = False
				break
		if d:
			e = i
			break
	print(e)


import sys
input = sys.stdin.readline
n = int(input())
s = input().strip('\n')
name = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for x in name:
	if len(x) == n:
		f = True
		for i in range(n):
			if s[i] != '.' and s[i] != x[i]:
				f = False
				break
		if f:
			print(x)
			break


possible = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
l = int(input())
pokemon = input()
pos = []
if l == 6:
	print('espeon')
elif l == 8:
	print('vaporeon')
else:
	for i in range(6):
		b = 0
		pok = possible[i]
		for j in range(7):
			for l in pok[j]:
				if l in pokemon[j]:
					b = b + 1
		pos.append(b)
	print(possible[pos.index(max(pos))])


import re
n = input()
list = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
s = '^' + input() + '$'
for t in list:
	if re.match(s, t):
		print(t)
		break


a = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']

def eevee(s):
	for elem in a:
		if len(elem) != len(s):
			continue
		flag = True
		for j in range(len(s)):
			if s[j] != '.' and elem[j] != '.' and (s[j] != elem[j]):
				flag = False
		if flag:
			return elem
	return -1
n = int(input())
t = input()
print(eevee(t))


import re
src = input()
src = input()
data = ['Vaporeon', 'Jolteon', 'Flareon', 'Espeon', 'Umbreon', 'Leafeon', 'Glaceon', 'Sylveon']
for mon in data:
	mon = mon.lower()
	if len(mon) != len(src):
		continue
	if re.match(src, mon):
		print(mon)
		break


s = [[]] * 8
s[0] = 'jolteon'
s[1] = 'flareon'
s[2] = 'espeon'
s[3] = 'umbreon'
s[4] = 'leafeon'
s[5] = 'glaceon'
s[6] = 'sylveon'
s[7] = 'vaporeon'
n = int(input())
ch = input()
il = 0
ss = 0
p = [[]] * 8
o = 0
while o < 8:
	p[o] = 0
	o += 1
if n == 7:
	while il < 7:
		ss = 0
		while ss < len(s[il]):
			if ch[ss] == s[il][ss] and n == len(s[il]):
				p[il] += 1
			ss += 1
		il += 1
	i = 0
	ii = 0
	while i < 8:
		if p[i] == max(p):
			ii = i
		i += 1
	print(s[ii])
elif n == 6:
	print('espeon')
else:
	print('vaporeon')


evo = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
t = int(input())
name = input()
pos = []
for i in evo:
	if len(i) == t:
		pos.append(i)
final = []
for j in pos:
	c = True
	for i in range(t):
		if name[i] == '.' or name[i] == j[i]:
			continue
		else:
			c = False
	if c:
		print(j)
		break


Evolution_Eevee = {'Vaporeon': '8', 'Jolteon': '7', 'Flareon': '7', 'Espeon': '6', 'Umbreon': '7', 'Leafeon': '7', 'Glaceon': '7', 'Sylveon': '7'}
n = int(input())
if 6 <= n <= 8:
	string = input()
	for (key, val) in Evolution_Eevee.items():
		if int(val) == n:
			count = 0
			value = len(string) - string.count('.')
			for i in range(n):
				if string[i].lower() == key[i].lower():
					count += 1
			if count == value:
				print(key.lower())


import sys
nameList = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
nameMap = {'vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon'}
resultList = []
line = input()
a = line.strip('\n').split()
length = int(a[0])
line = input()
mystring = line.strip('\n')
mylist = list(mystring)
count = 0
for name in nameList:
	if length == len(name):
		count = 0
		for char in mylist:
			if char != '.' and name[count] != char:
				break
			count += 1
		else:
			print(name)


from sys import stdin

def main():
	dic = [['j', 'o', 'l', 't', 'e', 'o', 'n'], ['f', 'l', 'a', 'r', 'e', 'o', 'n'], ['u', 'm', 'b', 'r', 'e', 'o', 'n'], ['l', 'e', 'a', 'f', 'e', 'o', 'n'], ['g', 'l', 'a', 'c', 'e', 'o', 'n'], ['s', 'y', 'l', 'v', 'e', 'o', 'n']]
	inp = stdin
	numero = int(inp.readline().strip())
	secreto = inp.readline().strip()
	if numero == 6:
		print('espeon')
	elif numero == 8:
		print('vaporeon')
	else:
		coincidencia = (0, 0)
		for i in range(0, len(dic)):
			coincide = 0
			for t in range(0, 7):
				if secreto[t] == dic[i][t]:
					coincide = coincide + 1
			if coincidencia[1] < coincide:
				coincidencia = (i, coincide)
		print(''.join(dic[coincidencia[0]]))
main()


pokemons = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = input()
transform = input()
for pokemon in pokemons:
	if len(pokemon) == len(transform) and all((pokemon[j] == transform[j] for j in range(len(transform)) if transform[j] != '.')):
		print(pokemon)
		exit()


n = int(input()) - 3
a = input()[:-3]
if n == 3:
	print('espeon')
elif n == 5:
	print('vaporeon')
else:
	l = 6
	words = ['jolt', 'flar', 'umbr', 'leaf', 'glac', 'sylv']
	for i in range(n):
		if a[i] != '.':
			j = 0
			while j < l:
				if words[j][i] != a[i]:
					words.pop(j)
					l -= 1
				else:
					j += 1
	if l == 1:
		print(words[0] + 'eon')
	else:
		print('flareon')


l_6 = ['espeon']
l_7 = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
l_8 = ['vaporeon']
input_length = input()
input_string = input()
if input_length == '6':
	print(l_6[0])
elif input_length == '8':
	print(l_8[0])
else:
	for x in l_7:
		for y in range(0, 7):
			if input_string[y] != '.' and input_string[y] != x[y]:
				break
			if y == 6:
				print(x)


a = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
x = int(input())
b = input()
pos = []
if x == 8:
	print('vaporeon')
elif x == 6:
	print('espeon')
else:
	for q in range(7):
		if b[q] == '.':
			continue
		else:
			pos.append(q)
	for q in a:
		ass = True
		for w in pos:
			if b[w] != q[w]:
				ass = False
				break
		if ass:
			print(q)


import re
n = int(input())
s = input()
reg_search = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for i in reg_search:
	if len(i) == n and re.search(s, i):
		print(i)


arr = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
s = input()
if n == 6:
	print('espeon')
elif n == 8:
	print('vaporeon')
else:
	for i in range(len(arr)):
		if len(arr[i]) != n:
			arr[i] = 'x'
	for i in range(4):
		if s[i] != '.':
			for j in range(len(arr)):
				if arr[j] != 'x':
					if arr[j][i] != s[i]:
						arr[j] = 'x'
	for i in arr:
		if i != 'x':
			print(i)


names = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
(n, s) = (int(input()), input())
for name in names:
	if len(name) == n and all((ch1 == '.' or ch1 == ch2 for (ch1, ch2) in zip(s, name))):
		print(name)
		break


from difflib import SequenceMatcher

def similar(a, b):
	return SequenceMatcher(None, a, b).ratio()
poke = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
s = input()
k = 0
pok = ''
for i in poke:
	if similar(i, s) >= k and n == len(i):
		k = similar(i, s)
		pok = i
print(pok)


def isOk(s, t):
	if len(s) != len(t):
		return False
	for i in range(len(s)):
		if t[i] != '.' and s[i] != t[i]:
			return False
	return True

def main():
	A = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
	n = int(input())
	t = input()
	for s in A:
		if isOk(s, t):
			print(s)
			return
main()


def bestmatch(n, st):
	namelist = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
	for i in namelist[:]:
		if len(i) != n:
			namelist.remove(i)
	matchcount = []
	for name in namelist:
		c = 0
		for j in range(n):
			if st[j] == name[j]:
				c += 1
		matchcount.append(c)
	return namelist[matchcount.index(max(matchcount))]

def main():
	n = int(input())
	st = input()
	print(bestmatch(n, st))
main()


def clFn(value):
	try:
		int(value)
		return int(value)
	except:
		try:
			float(value)
			return float(value)
		except:
			return value
number = int(input())
magicWord = input()
lenMagicWord = len(magicWord)
names = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
mayAnswer = []
for k in names:
	if len(k) == lenMagicWord:
		mayAnswer.append(k)
letterExist = {}
for index in range(lenMagicWord):
	if magicWord[index] != '.':
		letterExist[index] = magicWord[index]
for work in mayAnswer:
	exit = True
	for (k, j) in letterExist.items():
		if k < len(work) and work[k] != j:
			exit = False
	if exit:
		print(work)
		break


unl = int(input())
a = str(input())
b = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
x = 0
while x < 8:
	if len(b[x]) == len(a):
		y = 0
		match = 0
		while y < unl:
			if a[y] == '.' or a[y] == b[x][y]:
				match += 1
			else:
				break
			y += 1
		if match == unl:
			print(b[x])
			break
	x += 1


import re
n = input()
s = input()
for t in ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']:
	if len(s) == len(t) and hasattr(re.match('(' + s + ')', t), 'groups'):
		print(t)
		break


flag = 0
l = 1
st = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input(''))
stt = input('')
for i in range(8):
	if len(st[i]) == n:
		for j in range(n):
			if stt[j] == '.':
				continue
			else:
				l = 0
				if st[i][j] == stt[j]:
					flag = 1
				else:
					flag = 0
					break
		if flag == 1:
			print(st[i])
		elif l == 1:
			print(st[i])


n = int(input())
name = input()
if n == 6:
	print('espeon')
elif n == 8:
	print('vaporeon')
else:
	names = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
	flag = [1] * 6
	for i in range(6):
		for j in range(7):
			if names[i][j] != name[j] and name[j] != '.':
				flag[i] = 0
	for i in range(6):
		if flag[i] == 1:
			print(names[i])
			break


w = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
s = input()
p = [w[i] for i in range(len(w)) if len(w[i]) == n]
for i in range(n):
	if s[i] == '.':
		continue
	new_pos = []
	for j in p:
		if j[i] == s[i]:
			new_pos.append(j)
	p = new_pos[:]
print(p[0])


a = int(input())
b = input()
l = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
p = len(b)
m = 0
d = [0 for i in range(6)]
if p == 8:
	print('vaporeon')
elif p == 6:
	print('espeon')
else:
	for i in range(4):
		s = b[i]
		for j in range(6):
			if s == l[j][i]:
				d[j] = d[j] + 1
	m = max(d)
	n = d.index(m)
	print(l[n])


pokemons = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
x = input()

def matches(pattern, word):
	if len(pattern) != len(word):
		return False
	for i in range(len(word)):
		if pattern[i] != '.' and pattern[i] != word[i]:
			return False
	return True
for pokemon in pokemons:
	if matches(x, pokemon):
		print(pokemon)
		break


n = int(input())
s = input()
l = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
import re
li = [i for i in l if len(i) == n]
for i in li:
	match = re.search(s, i)
	if match != None:
		print(i)
		break


n = int(input())
STR = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
INNIT = list(input())
if n == 8:
	print('vaporeon')
if n == 6:
	print('espeon')
else:
	MAX = 0
	ans = ''
	for i in range(1, 8):
		kolvo = 0
		qwe = STR[i]
		qwe = list(str(qwe))
		if len(INNIT) == len(qwe):
			for j in range(len(INNIT)):
				if qwe[j] == INNIT[j]:
					kolvo += 1
			if MAX < kolvo:
				MAX = kolvo
				ans = STR[i]
	print(ans)


def prov(s2):
	global s1
	if len(s1) != len(s2):
		return False
	for i in range(len(s1)):
		if s1[i] != s2[i] and s1[i] != '.':
			return False
	print(s2)
	exit(0)
n = int(input())
s1 = input().strip()
b = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for i in b:
	prov(i)


num = int(input())
clue = str(input())
names = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for evo in names:
	flag = True
	if len(evo) == num:
		for i in range(num):
			if clue[i] != '.' and clue[i] != evo[i]:
				flag = False
				break
		if flag == True:
			print(evo)


import re
n = int(input())
s = input()
l = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for p in l:
	if len(p) != len(s):
		continue
	for i in range(n):
		if s[i] != p[i] and s[i] != '.':
			break
	else:
		print(p)


ref = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
s = str(input())
output = ''
for j in range(len(ref)):
	if len(ref[j]) != n:
		continue
	(alpha, count) = (0, 0)
	for k in range(n):
		if s[k] >= 'a' and s[k] <= 'z':
			alpha += 1
			if s[k] == ref[j][k]:
				count += 1
	if count == alpha:
		output = ref[j]
		break
print(output)


n = int(input())
s = ['vaporeon']
s1 = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
s2 = ['espeon']
st = input()
if n == 8:
	print(s[0])
elif n == 6:
	print(s2[0])
else:
	for i in s1:
		f = True
		kr = 0
		for j in range(n):
			if st[j] != '.':
				kr += 1
				try:
					if st[j] != i[j]:
						f = False
				except:
					f = False
		if f:
			print(i)
			break


import sys
f = sys.stdin
n = int(f.readline().strip())
s = f.readline().strip()
v = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for vi in v:
	t = True
	if n != len(vi):
		t = False
		continue
	for l in range(len(s)):
		if s[l] != '.' and vi[l] != s[l]:
			t = False
			break
	if t:
		res = vi
		break
print(res)


n = int(input())
s = input().strip()
a = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for k in a:
	b = True
	if n == len(k):
		for i in range(n):
			if s[i] != '.' and s[i] != k[i]:
				b = False
		if b:
			print(k)
			exit()


import re
options = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
input()
matcher = re.compile('^' + input().strip() + '$')
for a in options:
	if matcher.search(a) is not None:
		print(a)
		break


pokemon = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
a = input()
for p in pokemon:
	if len(p) == n:
		for i in range(n):
			if a[i] != '.' and a[i] != p[i]:
				break
		else:
			print(p)
			exit()


import re
a = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
b = '^' + [*open(0)][1][:-1] + '$'
for x in a:
	if re.match(b, x):
		print(x)
		break


n = int(input())
s = input()
lno = []
lname = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for i in range(len(lname)):
	lno.append(len(lname[i]))
i = 0
while i < len(lno):
	if lno[i] != n:
		lno.pop(i)
		lname.pop(i)
	else:
		for j in range(n):
			if s[j] != '.' and s[j] != lname[i][j]:
				lno.pop(i)
				lname.pop(i)
				t = 0
				break
			else:
				t = 1
		if t == 1:
			print(lname[i])
			break


def ok(x, y):
	if len(x) != len(y):
		return False
	for i in range(len(x)):
		if y[i] != '.' and x[i] != y[i]:
			return False
	return True
n = int(input())
s = input()
L = ['Vaporeon', 'Jolteon', 'Flareon', 'Espeon', 'Umbreon', 'Leafeon', 'Glaceon', 'Sylveon']
for i in range(len(L)):
	L[i] = L[i].lower()
for item in L:
	if ok(item, s):
		print(item)
		break


n = int(input())
s = input()
l = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for given in l:
	if len(given) != len(s):
		continue
	istrue = 1
	for i in range(0, n):
		if given[i] != s[i] and s[i] != '.':
			istrue = 0
			break
	if istrue:
		print(given)


t = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
s = input()
ans = ''
for i in range(len(t)):
	if len(t[i]) != len(s):
		continue
	else:
		find = True
		for j in range(n):
			if s[j] != '.' and s[j] != t[i][j]:
				find = False
				break
		if find:
			ans = t[i]
			break
print(ans)


import re
p = ['espeon', 'jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon', 'vaporeon']
n = input()
s = input()
x = [i for i in p if re.search(s, i)]
print(x[0])


d = {}

def compute(s, i, root):
	if i >= len(root):
		d[s] = root
		return
	compute(s + root[i], i + 1, root)
	compute(s + '.', i + 1, root)
n = int(input())
s = input().strip()
store = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for x in d:
	print(x, d[x])
for x in store:
	compute('', 0, x)
print(d[s])


def main():
	n = int(input())
	s = input()
	st = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
	for pock in st:
		if len(pock) == len(s):
			bad = False
			for j in range(len(s)):
				if s[j] != '.' and s[j] != pock[j]:
					bad = True
					break
			if not bad:
				print(pock)
				return
main()


n = int(input())
word = input()
names = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
names2 = names[:]
if n == 8:
	print('vaporeon')
elif n == 6:
	print('espeon')
else:
	p = []
	for i in range(len(word)):
		if word[i] == '.':
			p.append(i)
	for i in range(len(names)):
		for j in range(len(names[i])):
			if j in p:
				names[i] = names[i][:j] + '.' + names[i][j + 1:]
	print(names2[names.index(word)])


p = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
m = 0
s = ''
n = int(input())
a = input()
for i in range(8):
	c = 0
	if len(p[i]) == n:
		if a == n * '.':
			s = p[i]
		else:
			for j in range(n):
				if p[i][j] == a[j]:
					c += 1
	if c > m:
		m = c
		s = p[i]
print(s)


import sys
import re
input()
r = re.compile('^' + input() + '$')
l = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for i in l:
	if r.match(i):
		print(i)
		sys.exit(0)


n = int(input())
s = input()
d = {'vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon'}
for pokemon in d:
	if len(pokemon) != n:
		continue
	is_ok = True
	for i in range(n):
		if s[i] != '.':
			if pokemon[i] != s[i]:
				is_ok = False
				break
	if is_ok:
		print(pokemon)
		exit(0)


n = int(input())
s = input().rstrip()
p = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for i in range(len(p)):
	if len(s) != len(p[i]):
		continue
	k = 0
	for j in range(n):
		if s[j] != '.' and s[j] != p[i][j]:
			k += 1
	if k == 0:
		print(p[i])
		exit(0)


def main():
	a = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
	n = int(input())
	s = input()
	for name in a:
		if len(name) == len(s):
			good = True
			for i in range(len(s)):
				if s[i] != '.':
					if name[i] != s[i]:
						good = False
						break
			if good:
				print(name)
main()


pokemon = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
no_name = input()
if n == 6:
	print('espeon')
elif n == 8:
	print('vaporeon')
else:
	for i in pokemon:
		for el in range(n):
			if no_name[el] != i[el] and no_name[el] != '.':
				break
			elif (no_name[el] == '.' or no_name[el] == i[el]) and el < 4:
				continue
			elif el >= 4:
				print(i)
				exit()


length = int(input())
name = input()
names = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
ind = []
if length == 6:
	print('espeon')
elif length == 8:
	print('vaporeon')
else:
	for i in range(0, 7):
		if name[i] != '.':
			ind.append(i)
	for i in ind:
		index = []
		try:
			if names[0][i] != name[i]:
				index.append(0)
		except:
			x = 1
		try:
			if names[1][i] != name[i]:
				index.append(1)
		except:
			x = 1
		try:
			if names[2][i] != name[i]:
				index.append(2)
		except:
			x = 1
		try:
			if names[3][i] != name[i]:
				index.append(3)
		except:
			x = 1
		try:
			if names[4][i] != name[i]:
				index.append(4)
		except:
			x = 1
		try:
			if names[5][i] != name[i]:
				index.append(5)
		except:
			x = 1
		index.reverse()
		for j in index:
			del names[j]
	print(names[0])


n = int(input())
s = str(input())
if n == 8:
	print('vaporeon')
elif n == 6:
	print('espeon')
elif s[0] == 'j' or s[1] == 'o' or s[3] == 't':
	print('jolteon')
elif s[0] == 's' or s[1] == 'y' or s[3] == 'v':
	print('sylveon')
elif s[0] == 'u' or s[1] == 'm' or s[2] == 'b':
	print('umbreon')
elif s[0] == 'l' or s[1] == 'e' or s[3] == 'f':
	print('leafeon')
elif s[0] == 'g' or s[3] == 'c':
	print('glaceon')
else:
	print('flareon')


book = ('vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon')
n = int(input())
line = str(input())
for it in book:
	if len(it) == n:
		flag = True
		for (i, j) in zip(line, it):
			if i != '.' and i != j:
				flag = False
		if flag:
			print(it)
			break


import re
(n, p) = (int(input()), re.compile(input()))
print(next((x for x in ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon'] if len(x) == n and p.match(x))))


import re
n = int(input())
p = input()
s = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for i in s:
	if re.match(p, i) and len(i) == len(p):
		print(i)
		break


l = ['vaporeon', 'jolteon', 'leafeon', 'flareon', 'espeon', 'umbreon', 'glaceon', 'sylveon']
n = int(input())
s = input()
c = 0
x = 0
for i in s:
	if i != '.':
		c = c + 1
for j in l:
	x = 0
	for i in s:
		if i in j:
			x = x + 1
	if x == c and len(j) == n:
		print(j)
		break


import re
n = int(input())
s = input()
forms = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for form in forms:
	if re.fullmatch(s, form) is not None:
		print(form)


n = int(input())
s = input()
a = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
b = [1] * 8
t = 0
for i in s:
	for j in range(0, 8):
		if len(a[j]) != len(s) or (len(a[j]) > t and a[j][t] != i and (i != '.')):
			b[j] = 0
	t = t + 1
k = 0
for k in range(0, 8):
	if b[k] == 1:
		print(a[k])


s = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
d = []
n = int(input())
a = input()
for i in range(8):
	if len(s[i]) == n:
		b = s[i]
		cnt = 0
		for j in range(n):
			if a[j] == '.':
				pass
			elif a[j] != b[j]:
				cnt += 1
		if cnt == 0:
			d.append(s[i])
print(*d)


n = int(input())
s = input()
d = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for y in d:
	p = True
	if len(s) == len(y):
		for i in range(len(s)):
			if s[i] != '.' and s[i] != y[i]:
				p = False
		if p:
			print(y)


a = ['vaporeon', 'espeon', 'jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
if n == 6:
	print(a[1])
elif n == 8:
	print(a[0])
else:
	s = input()
	for i in range(2, 8):
		t = a[i]
		f = 1
		for j in range(7):
			if s[j] != '.' and s[j] != t[j]:
				f = 0
				break
		if f == 1:
			print(t)
			break


names = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
poss = []
length = int(input())
n = input()
for name in names:
	if len(name) != len(n):
		continue
	success = True
	for l in range(len(name)):
		letter = name[l]
		otherLetter = n[l]
		if otherLetter != '.' and letter != otherLetter:
			success = False
			break
	if success:
		print(name)
		break


length = int(input())
eevee = input()
if length == 6:
	print('espeon')
elif length == 8:
	print('vaporeon')
elif eevee[0] == 'j' or eevee[1] == 'o' or eevee[3] == 't':
	print('jolteon')
elif eevee[0] == 'f' or (eevee[1] == 'l') & (eevee[3] == 'r') or (eevee[2] == 'a') & (eevee[3] == 'r'):
	print('flareon')
elif eevee[0] == 'u' or eevee[1] == 'm' or eevee[2] == 'b' or (eevee[3] == 'r'):
	print('umbreon')
elif eevee[0] == 'l' or eevee[1] == 'e' or eevee[3] == 'f':
	print('leafeon')
elif eevee[0] == 'g' or eevee[1] == 'l' or eevee[2] == 'a' or (eevee[3] == 'c'):
	print('glaceon')
else:
	print('sylveon')


pokemons = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
length = int(input())
misspelled = input()
cur_pok = list(filter(lambda x: len(x) == length, pokemons))
for c in range(0, len(misspelled)):
	if misspelled[c] != '.':
		cur_pok = list(filter(lambda x: x[c] == misspelled[c], cur_pok))
print(cur_pok[0])


Pokemons = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
P = [True, True, True, True, True, True, True, True]
n = int(input())
s = input()
for (i, x) in enumerate(Pokemons):
	if len(x) != n:
		P[i] = False
	else:
		for (j, c) in enumerate(s):
			if c != x[j] and c != '.':
				P[i] = False
for (i, p) in enumerate(P):
	if p == True:
		print(Pokemons[i])


pokemon = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
length = int(input())
unknown_name = input()
possiblePokemon = []
for current_pokemon in pokemon:
	if len(current_pokemon) == length:
		possiblePokemon.append(current_pokemon)
if len(possiblePokemon) == 1:
	print(possiblePokemon[0])
else:
	i = 0
	for (i, character) in enumerate(unknown_name):
		if character == '.':
			continue
		j = 0
		while j < len(possiblePokemon):
			current_pokemon = possiblePokemon[j]
			if current_pokemon[i] != character:
				del possiblePokemon[j]
			else:
				j += 1
		if len(possiblePokemon) == 1:
			print(possiblePokemon[0])
			break
	else:
		print(possiblePokemon)


import re
strLen = int(input())
name = input()
names = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
regex = re.compile('^' + name + '$')
for n in names:
	if regex.match(n):
		print(n)
		break


n = int(input())
w = input()
l = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
for i in l:
	if len(w) == len(i):
		p = ''
		j = 0
		while j < len(w):
			if w[j] == '.':
				p += i[j]
			elif w[j] == i[j]:
				p += i[j]
			else:
				break
			j += 1
		if p in l:
			print(p)
			break


def main():
	n = int(input())
	s = input()
	for p in ('vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon'):
		if len(p) == n and all((a == b or a == '.' for (a, b) in zip(s, p))):
			print(p)
			return
main()


n = int(input())
s = input()
vrs = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']

def match(a, b):
	if len(a) != len(b):
		return False
	for (ac, bc) in zip(a, b):
		if ac == '.' or bc == '.':
			continue
		elif ac != bc:
			return False
	return True
for i in vrs:
	if match(s, i):
		print(i)
		break


pokemon = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
avail = [0, 0, 0, 0, 0, 0]
n = int(input())
cwd = input()
if n == 6:
	print('espeon')
	exit(0)
if n == 8:
	print('vaporeon')
	exit(0)
for i in range(n):
	if cwd[i] == '.':
		continue
	else:
		for j in range(6):
			if avail[j] is 0 and pokemon[j][i] is not cwd[i]:
				avail[j] = 1
	if avail.count(0) is 1:
		for j in range(6):
			if avail[j] is 0:
				print(pokemon[j])
		exit(0)


iwannabethebest = ['jolteon', 'flareon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
(n, s) = (int(input()), str(input()))
if n != 7:
	print('vaporeon' if n == 8 else 'espeon')
else:
	for pikachu in iwannabethebest:
		testforthebest = True
		for i in range(n):
			if s[i] != '.' and s[i] != pikachu[i]:
				testforthebest = False
		if testforthebest:
			print(pikachu)
			break


l = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
length = []
mstr = []
n = int(input())
st = input()
for i in l:
	st2 = i
	ln = len(st)
	if ln == len(st2):
		match = sum((a == b for (a, b) in zip(st2, st)))
		length.append(match)
		mstr.append(i)
maxLen = max(length)
maxIn = length.index(maxLen)
print(mstr[maxIn])


names = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
temp = names[:]
n = int(input())
for x in range(8):
	if len(temp[x]) != n:
		names.remove(temp[x])
s = input()
for x in names:
	for y in range(n):
		if s[y] != '.' and x[y] != s[y]:
			break
	else:
		print(x)
		break


evolutions = ['vaporeon', 'jolteon', 'flareon', 'espeon', 'umbreon', 'leafeon', 'glaceon', 'sylveon']
n = int(input())
s = input()
for i in range(8):
	j = 0
	if len(evolutions[i]) == n:
		while j < n:
			if evolutions[i][j] != s[j] and s[j] != '.':
				break
			j += 1
		if j == n:
			print(evolutions[i])
			break