You are given two strings $s$ and $t$, both consisting of exactly $k$ lowercase Latin letters, $s$ is lexicographically less than $t$.

Let's consider list of all strings consisting of exactly $k$ lowercase Latin letters, lexicographically not less than $s$ and not greater than $t$ (including $s$ and $t$) in lexicographical order. For example, for $k=2$, $s=$"az" and $t=$"bf" the list will be ["az", "ba", "bb", "bc", "bd", "be", "bf"].

Your task is to print the median (the middle element) of this list. For the example above this will be "bc".

It is guaranteed that there is an odd number of strings lexicographically not less than $s$ and not greater than $t$.


-----Input-----

The first line of the input contains one integer $k$ ($1 \le k \le 2 \cdot 10^5$) — the length of strings.

The second line of the input contains one string $s$ consisting of exactly $k$ lowercase Latin letters.

The third line of the input contains one string $t$ consisting of exactly $k$ lowercase Latin letters.

It is guaranteed that $s$ is lexicographically less than $t$.

It is guaranteed that there is an odd number of strings lexicographically not less than $s$ and not greater than $t$.


-----Output-----

Print one string consisting exactly of $k$ lowercase Latin letters — the median (the middle element) of list of strings of length $k$ lexicographically not less than $s$ and not greater than $t$.


-----Examples-----
Input
2
az
bf

Output
bc

Input
5
afogk
asdji

Output
alvuw

Input
6
nijfvj
tvqhwp

Output
qoztvz

Difficulty: HARD

Solutions:
def plus(a, b):
	c = ''
	i = len(a) - 1
	arg = 0
	while i >= 0:
		k = arg + ord(a[i]) + ord(b[i]) - 194
		arg = 1
		if k < 26:
			arg = 0
		i -= 1
		c = chr(k % 26) + c
	c = chr(1) * arg + c
	return c

def minus(a):
	c = ''
	i = 0
	arg = 0
	while i < len(a):
		c += chr((arg * 26 + ord(a[i])) // 2)
		arg = ord(a[i]) % 2
		i += 1
	if arg:
		c = c[:len(c) - 1] + chr(ord(c[len(c) - 1]) + 1)
	return c
n = int(input())
a = input()
b = input()
a1 = ''
b1 = ''
i = 0
while i < n:
	a1 += chr(ord(a[i]))
	b1 += chr(ord(b[i]))
	i += 1
c = plus(a1, b1)
c = minus(c)
c1 = ''
for q in c:
	c1 += chr(ord(q) + ord('a'))
print(c1[len(c1) - n:])


def plus(a, b):
	c = ''
	i = len(a) - 1
	arg = 0
	while i >= 0:
		k = (arg + ord(a[i]) + ord(b[i])) % 26
		if arg + ord(a[i]) + ord(b[i]) < 26:
			arg = 0
		else:
			arg = 1
		i -= 1
		c = chr(k) + c
	if arg:
		c = chr(1) + c
	return c

def minus(a):
	c = ''
	i = 0
	arg = 0
	while i < len(a):
		c += chr((arg * 26 + ord(a[i])) // 2)
		arg = ord(a[i]) % 2
		i += 1
	if arg:
		c = c[:len(c) - 1] + chr(ord(c[len(c) - 1]) + 1)
	return c
n = int(input())
a = input()
b = input()
ai = 0
bi = 0
a1 = ''
b1 = ''
i = 0
while i < n:
	a1 += chr(ord(a[i]) - ord('a'))
	b1 += chr(ord(b[i]) - ord('a'))
	i += 1
c = plus(a1, b1)
c = minus(c)
i = 0
c1 = ''
while i < len(c):
	c1 += chr(ord(c[i]) + ord('a'))
	i += 1
print(c1[len(c1) - n:])


from collections import deque
k = int(input())
s = input()
t = input()
alphabets = list('abcdefghijklmnopqrstuvwxyz')
to_digit = {}
for (i, c) in enumerate(alphabets):
	to_digit[c] = i
summation = deque()
carry = 0
for i in range(k - 1, -1, -1):
	dig = to_digit[s[i]] + to_digit[t[i]] + carry
	if dig > to_digit['z']:
		dig -= 26
		carry = 1
	else:
		carry = 0
	dig = chr(dig + ord('a'))
	summation.appendleft(dig)
l = k
r = 0
if carry == 1:
	r = 1
result = []
for i in range(l):
	term = to_digit[summation[i]]
	if r == 1:
		term += 26
	(q, r) = divmod(term, 2)
	q = chr(q + ord('a'))
	result.append(q)
print(''.join(result))


k = int(input())
s = input().strip()
t = input().strip()
num_2 = list(map(ord, s))
num_1 = list(map(ord, t))
for i in range(k):
	num_1[i] -= 97
	num_2[i] -= 97

def plus(num_1, num_2):
	res = [0] * (len(num_1) + 1)
	memory = 0
	num_1.reverse()
	num_2.reverse()
	for i in range(len(num_1)):
		add = num_1[i] + num_2[i] + memory
		res[i] = add % 26
		memory = add // 26
	res.reverse()
	res[0] = memory
	return res

def div_2(num):
	memory = 0
	res = [0] * len(num)
	for i in range(len(num)):
		res[i] = (num[i] + memory * 26) // 2
		memory = (num[i] + memory * 26) % 2
	return res
summ = plus(num_1, num_2)
res = div_2(summ)
print(''.join((chr(i + 97) for i in res[1:])))


from math import ceil
k = int(input())
s = input()
t = input()
soma_s = []
soma_t = []
for i in range(k):
	soma_s.append(ord(s[i]) - ord('a'))
	soma_t.append(ord(t[i]) - ord('a'))
for i in range(k - 1, -1, -1):
	soma_s[i] += soma_t[i]
	if i != 0:
		soma_s[i - 1] += soma_s[i] // 26
		soma_s[i] = soma_s[i] % 26
med = ''
for i in range(k):
	valor = soma_s[i] // 2
	if i < k - 1:
		soma_s[i + 1] += soma_s[i] % 2 * 26
	med += chr(ord('a') + valor)
print(med)


k = int(input())

def f(s):
	r = [0] * k
	for (i, c) in enumerate(s):
		r[i] = ord(c) - ord('a')
	return r
s = input()
t = input()
sr = f(s)
st = f(t)
for i in range(k - 1, -1, -1):
	sr[i] += st[i]
	if i > 0:
		sr[i - 1] += sr[i] // 26
		sr[i] %= 26
for i in range(k):
	r = sr[i] % 2
	sr[i] = sr[i] // 2
	if i < k - 1:
		sr[i + 1] += r * 26
for i in range(k):
	sr[i] = chr(ord('a') + sr[i])
print(''.join(sr))


def add(a, b):
	c = []
	z = 0
	for i in range(k - 1, -1, -1):
		x = ord(a[i]) - ord('a')
		y = ord(b[i]) - ord('a')
		if x + y + z >= 26:
			c.append(x + y + z - 26)
			z = 1
		else:
			c.append(x + y + z)
			z = 0
	if z:
		c.append(z)
	return c[::-1]

def div2(a):
	c = []
	z = 0
	for x in a:
		x += 26 * z
		c.append(chr(ord('a') + x // 2))
		z = x % 2
	return c
k = int(input())
a = input()
b = input()
d = div2(add(a, b))
if len(d) > k:
	d = d[len(d) - k:]
print(''.join(d))


def decto26(n):
	a = []
	while n > 0:
		a.insert(0, n % 26)
		n //= 26
	return a

def f26todec(a):
	n = 0
	l = len(a) - 1
	for i in a:
		n += i * 26 ** l
		l -= 1
	return n

def sum26(a, b, n):
	q = 0
	c = []
	for i in range(n + 1):
		c.append(0)
	for i in range(n, 0, -1):
		c[i] = (a[i - 1] + b[i - 1] + q) % 26
		q = (a[i - 1] + b[i - 1] + q) // 26
	c[0] += q
	return c

def del26(a):
	n = len(a)
	q = a[0]
	c = []
	for i in range(n):
		c.append(0)
	for i in range(n - 1):
		c[i] += a[i] // 2
		if a[i] % 2 == 1:
			a[i + 1] += 26
	c[-1] = a[-1] // 2
	if q <= 1:
		c.pop(0)
	return c
abc = 'abcdefghijklmnopqrstuvwxyz'
k = int(input())
s = input()
a = []
for i in s:
	a.append(abc.index(i))
sm = a
t = input()
a = []
for i in t:
	a.append(abc.index(i))
tm = a
a = del26(sum26(sm, tm, k))
b = ''
for i in a:
	b += abc[i]
print(b)


import string, copy

def _value(c):
	return ord(c) - 97

def _char(i):
	return chr(i + 97)

def solution(s1, s2):
	s1 = [_value(c) for c in s1]
	s2 = [_value(c) for c in s2]
	sum_s = []
	tmp = 0
	for i in range(len(s1) - 1, -1, -1):
		s = s1[i] + s2[i] + tmp
		tmp = s // 26
		sum_s.append(s % 26)
	if tmp:
		sum_s.append(tmp)
	sum_s = sum_s[::-1]
	tmp = 0
	result = []
	for i in range(len(sum_s)):
		s = sum_s[i]
		result.append((s + 26 * tmp) // 2)
		tmp = s % 2
	result = result[-len(s1):]
	result = [_char(i) for i in result]
	return ''.join(result)

def parser():
	n = int(input())
	s1 = input()
	s2 = input()
	return (s1, s2)

def output(s):
	print(s)

def main():
	args = parser()
	result = solution(*args)
	output(result)
main()


dic = {}
dic2 = {}
for i in range(97, 123):
	dic[chr(i)] = i
	dic2[i] = chr(i)
k = int(input())
word1 = input()
word2 = input()
ords = []
carry = 0
for i in range(k):
	c = dic[word1[i]] + dic[word2[i]] + carry
	carry = 0
	if c % 2 == 1:
		carry = 26
	ords.append(c // 2)
for i in range(k - 1, -1, -1):
	if ords[i] > 122:
		ords[i - 1] += 1
		ords[i] = dic2[ords[i] - 26]
	else:
		ords[i] = dic2[ords[i]]
p = ''
for o in ords:
	p += o
print(p)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	n = I()
	s = [ord(c) - ord('a') for c in S()]
	t = [ord(c) - ord('a') for c in S()]
	r = [s[i] + t[i] for i in range(n)]
	for i in range(n - 1, 0, -1):
		if r[i] >= 26:
			r[i] -= 26
			r[i - 1] += 1
	k = 0
	rs = []
	for i in range(n):
		b = r[i] + k
		rs.append(chr(b // 2 + ord('a')))
		if b % 2 == 0:
			k = 0
		else:
			k = 26
	return ''.join(rs)
print(main())


k = int(input())
s = input()
t = input()
s = [ord(s[i]) - ord('a') for i in range(k)]
t = [ord(t[i]) - ord('a') for i in range(k)]
res = [0] * (k + 1)
add = 0
for i in range(k - 1, -1, -1):
	sum = t[i] + s[i] + add
	add = sum // 26
	res[i + 1] = sum % 26
res[0] = add
add = 0
ans = []
for i in range(k + 1):
	d = add * 26 + res[i]
	add = d % 2
	ans.append(d // 2)
print(''.join(map(lambda x: chr(x + ord('a')), ans[1:])))


indexes = {}
alpha = 'abcdefghijklmnopqrstuvwxyz'
for i in alpha:
	indexes[i] = alpha.index(i)
n = int(input())
first = [indexes[x] for x in input()]
second = [indexes[x] for x in input()]
third = [0] * n
carry = 0
for i in range(n - 1, -1, -1):
	tempResp = first[i] + second[i] + carry
	if i != 0 and tempResp >= 26:
		carry = 1
		tempResp = tempResp - 26
	else:
		carry = 0
	third[i] = tempResp
carry = 0
for i in range(n):
	comCarry = third[i] + carry * 26
	third[i] = comCarry // 2
	if comCarry % 2 != 0:
		carry = 1
	else:
		carry = 0
print(''.join((alpha[k] for k in third)))


dicti = {}
for i in range(26):
	dicti[chr(97 + i)] = i + 1
k = int(input())
str1 = list(input())
str2 = list(input())
delta = []
for i in range(k):
	str1[i] = dicti[str1[i]]
	str2[i] = dicti[str2[i]]
	delta.append(str2[i] - str1[i])
for i in range(k - 1, 0, -1):
	if delta[i] < 0:
		delta[i - 1] -= 1
		delta[i] += 26
divide = []
for i in range(k - 1):
	divide.append(delta[i])
	if delta[i] % 2 != 0:
		divide[i] = delta[i] // 2
		delta[i + 1] += 26
	else:
		divide[i] = delta[i] // 2
divide.append(delta[-1] // 2)
ans = [0 for i in range(k)]
for i in range(k - 1, -1, -1):
	sumi = str1[i] + divide[i]
	if sumi > 26:
		sumi -= 26
		if i != 0:
			divide[i - 1] += 1
	ans[i] = chr(96 + sumi)
print(*ans, sep='')


import sys
import math
sys.setrecursionlimit(20000000)
input = sys.stdin.readline
n = int(input())
s = [ord(i) - ord('a') for i in input().strip()]
t = [ord(i) - ord('a') for i in input().strip()]
for i in range(n):
	s[i] += t[i]
for i in range(1, len(s)):
	if s[i] >= 26:
		b = i
		while s[b] >= 26 and b != 0:
			s[b - 1] += 1
			s[b] -= 26
			b -= 1
for i in range(len(s)):
	if s[i] % 2 == 1:
		s[i + 1] += 26
		s[i] -= 1
	s[i] //= 2
for i in range(len(s)):
	s[i] = chr(s[i] + ord('a'))
print(''.join(s))


n = int(input())
a = list(input())
b = list(input())
dic = {}
dic2 = {}
ans = [0 for _ in range(n)]
for i in range(26):
	text = chr(97 + i)
	dic[text] = i
	dic2[str(i)] = text
for i in range(n - 1, -1, -1):
	down = dic[a[i]]
	if ord(b[i]) < 97:
		up = 25
		b[i - 1] = chr(ord(b[i - 1]) - 1)
		ans[i] = up - down
	else:
		up = dic.get(b[i])
		if up >= down:
			ans[i] = up - down
		else:
			b[i - 1] = chr(ord(b[i - 1]) - 1)
			ans[i] = 26 + up - down
left = 0
add = 0
for i in range(n):
	l = (left * 26 + ans[i]) % 2
	ans[i] = (left * 26 + ans[i]) // 2
	left = l
for i in range(n - 1, -1, -1):
	num = dic.get(a[i]) + ans[i] + add
	if num > 25:
		num %= 26
		add = 1
	else:
		add = 0
	a[i] = dic2.get(str(num))
print(''.join(a))


def divide_2(a, m):
	r = 0
	q = []
	for x in a:
		cur = r * m + x
		q.append(cur // 2)
		r = cur % 2
	return q

def add(s, t, m):
	r = 0
	a = []
	for (x, y) in zip(s[::-1], t[::-1]):
		cur = r + x + y
		a.append(cur % m)
		r = cur // m
	if r != 0:
		a.append(r)
	return a[::-1]

def to_num(s):
	a = []
	for x in s:
		a.append(ord(x) - ord('a'))
	return a

def to_char(s, k):
	a = []
	for x in s[-k:]:
		a.append(chr(x + ord('a')))
	return ''.join(a)
k = int(input())
x = to_num(input())
y = to_num(input())
print(to_char(divide_2(add(x, y, 26), 26), k))


n = int(input())
s = [ord(c) - 97 for c in input()]
t = [ord(c) - 97 for c in input()]
a = []
b = 0
p = n - 1
temp = t[p] + s[p]
while p > 0:
	p -= 1
	temp += (t[p] + s[p]) * 26
	a.append(chr(int(temp / 2) % 26 + 97))
	temp //= 26
a.append(chr(int(temp / 2) % 26 + 97))
p = n
while p:
	p -= 1
	print(a[p], end='')


n = int(input())
a = input()
b = input()
ch_a = []
ch_b = []
ch_re = [0] * n
for i in range(n):
	ch_a.append(int(ord(a[i]) - ord('a')))
	ch_b.append(int(ord(b[i]) - ord('a')))
flag = 0
for i in range(n - 1, -1, -1):
	temp = ch_a[i] + ch_b[i] + flag
	ch_re[i] = temp % 26
	flag = temp // 26
if flag == 1:
	ch_re[0] += 26
	flag = 0
for i in range(n):
	if flag:
		ch_re[i] += 26
	flag = int(ch_re[i] % 2)
	ch_re[i] = int(ch_re[i] // 2)
	ch_re[i] = chr(ch_re[i] + ord('a'))
print(''.join(ch_re))


alphabet = 'abcdefghijklmnopqrstuvwxyz'
alphabet_d = {}
for (i, c) in enumerate(alphabet):
	alphabet_d[c] = i

def transform_string(s):
	n = len(s)
	res = [0]
	for i in range(n):
		res.append(alphabet_d[s[i]])
	return res
k = int(input())
s = input()
t = input()
s = transform_string(s)
t = transform_string(t)
for i in range(k, -1, -1):
	s[i] += t[i]
	if i:
		s[i - 1] += s[i] // 26
		s[i] = s[i] % 26
for i in range(k + 1):
	rem = s[i] % 2
	s[i] = s[i] // 2
	if i + 1 <= k:
		s[i + 1] += rem * 26
	else:
		assert rem == 0
s = list(map(lambda x: alphabet[x], s[1:]))
print(''.join(s))


k = int(input())
s = input()
t = input()
num = [0] * k
num2 = [0] * k
alth = 'abcdefghijklmnopqrstuvwxyz'
for i in range(k):
	num[i] = alth.find(s[i])
	num2[i] = alth.find(t[i])
num3 = [0] * k
rem = 0
for i in range(k - 1, -1, -1):
	num3[i] = num2[i] - num[i] - rem
	if num3[i] < 0:
		num3[i] += 26
		rem = 1
	else:
		rem = 0
rem = 0
j = 0
while j < k:
	rem2 = (num3[j] + rem) % 2
	num3[j] = (num3[j] + rem) // 2
	rem = 26 * rem2
	j += 1
rem = 0
for i in range(k - 1, -1, -1):
	num[i] += num3[i] + rem
	if num[i] > 25:
		num[i] -= 26
		rem = 1
	else:
		rem = 0
for i in num:
	print(alth[i], end='')


n = int(input())
(s, t) = (input(), input())
a = [ord(i) - ord('a') for i in s]
b = [ord(i) - ord('a') for i in t]
(a, b, c) = (a[::-1], b[::-1], [0] * (n + 1))
for i in range(n):
	c[i] = c[i] + a[i] + b[i]
	c[i + 1] = c[i] // 26
	c[i] = c[i] % 26
c = c[::-1]
if c[0] == 0:
	c = c[1:]
ans = []
ost = 0
for digit in c:
	ost = ost * 26 + digit
	t = ost // 2
	ans.append(t)
	ost = digit % 2
if ans[0] == 0 and len(ans) > n:
	ans = ans[1:]
ans = ''.join([chr(i + ord('a')) for i in ans])
print(ans)


BASE = 26

def convertToNum(s):
	n = len(s)
	ret = [-1] * n
	for i in range(n - 1, -1, -1):
		ret[i] = ord(s[i]) - ord('a')
	return ret

def substract(a, b):
	n = len(a)
	ret = [-1] * n
	for i in range(n - 1, -1, -1):
		if b[i] > a[i]:
			a[i] += BASE
			a[i - 1] -= 1
		ret[i] = a[i] - b[i]
	return ret

def add(a, b):
	n = len(a)
	ret = [0] * n
	for i in range(n - 1, -1, -1):
		ret[i] += a[i] + b[i]
		if ret[i] > BASE - 1:
			ret[i] %= BASE
			ret[i - 1] = 1
	return ret

def divBy2(num):
	for i in range(len(num)):
		if num[i] & 1 == 1:
			num[i + 1] += BASE
		num[i] >>= 1
	return num

def convertToStr(num):
	return ''.join([chr(c + ord('a')) for c in num])
n = int(input())
start = input()
end = input()
(a, b) = (convertToNum(start), convertToNum(end))
print(convertToStr(add(a, divBy2(substract(b, a)))))


n = int(input())
s1 = input()
s2 = input()
m = ord('z') - ord('a') + 1
s1 = list(reversed(s1))
s2 = list(reversed(s2))
s3 = []
c = 0
for i in range(n):
	t = ord(s1[i]) + ord(s2[i]) - 2 * ord('a') + c
	s3.append(chr(t % m + ord('a')))
	c = t // m
if c != 0:
	s3.append(chr(c + ord('a')))
s3 = list(reversed(s3))
c = 0
ans = []
for i in s3:
	t = c * m + (ord(i) - ord('a'))
	c = t % 2
	ans.append(chr(ord('a') + t // 2))
if len(ans) > n:
	ans = ans[len(ans) - n:]
print(''.join(ans))


k = int(input())
s = str(input())
t = str(input())
(a, b, m) = ([], [], [])
(p, d) = (0, 0)
for i in range(k - 1, -1, -1):
	a.append(ord(s[i]) - ord('a'))
	b.append(ord(t[i]) - ord('a'))
	a[k - 1 - i] += b[k - 1 - i] + d
	d = a[k - 1 - i] // 26
	if i != 0:
		a[k - 1 - i] %= 26
carry = 0
for i in range(k - 1, -1, -1):
	current = a[i] + carry * 26
	a[i] = current // 2
	carry = current % 2
	print(chr(a[i] + 97), end='')


N = int(input())
s = input()
t = input()

def stoi(s):
	return ord(s) - 97

def itos(i):
	return chr(97 + i)

def stoL(s):
	L = []
	for ss in s:
		L.append(stoi(ss))
	return L
A = stoL(s)
B = stoL(t)
C = [A[i] + B[i] for i in range(N)]
for i in range(1, N)[::-1]:
	if C[i] >= 26:
		C[i] -= 26
		C[i - 1] += 1
t = 0
for i in range(N):
	if C[i] % 2:
		C[i] = (C[i] + t - 1) // 2
		t = 26
	else:
		C[i] = (C[i] + t) // 2
		t = 0
u = ''
for c in C:
	u += itos(c)
print(u)


import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
mod = 10 ** 9 + 7
mod1 = 998244353
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

class TreeNode:

	def __init__(self, k, v):
		self.key = k
		self.value = v
		self.left = None
		self.right = None
		self.parent = None
		self.height = 1
		self.num_left = 1
		self.num_total = 1

class AvlTree:

	def __init__(self):
		self._tree = None

	def add(self, k, v):
		if not self._tree:
			self._tree = TreeNode(k, v)
			return
		node = self._add(k, v)
		if node:
			self._rebalance(node)

	def _add(self, k, v):
		node = self._tree
		while node:
			if k < node.key:
				if node.left:
					node = node.left
				else:
					node.left = TreeNode(k, v)
					node.left.parent = node
					return node.left
			elif node.key < k:
				if node.right:
					node = node.right
				else:
					node.right = TreeNode(k, v)
					node.right.parent = node
					return node.right
			else:
				node.value = v
				return

	@staticmethod
	def get_height(x):
		return x.height if x else 0

	@staticmethod
	def get_num_total(x):
		return x.num_total if x else 0

	def _rebalance(self, node):
		n = node
		while n:
			lh = self.get_height(n.left)
			rh = self.get_height(n.right)
			n.height = max(lh, rh) + 1
			balance_factor = lh - rh
			n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
			n.num_left = 1 + self.get_num_total(n.left)
			if balance_factor > 1:
				if self.get_height(n.left.left) < self.get_height(n.left.right):
					self._rotate_left(n.left)
				self._rotate_right(n)
			elif balance_factor < -1:
				if self.get_height(n.right.right) < self.get_height(n.right.left):
					self._rotate_right(n.right)
				self._rotate_left(n)
			else:
				n = n.parent

	def _remove_one(self, node):
		replacement = node.left or node.right
		if node.parent:
			if AvlTree._is_left(node):
				node.parent.left = replacement
			else:
				node.parent.right = replacement
			replacement.parent = node.parent
			node.parent = None
		else:
			self._tree = replacement
			replacement.parent = None
		node.left = None
		node.right = None
		node.parent = None
		self._rebalance(replacement)

	def _remove_leaf(self, node):
		if node.parent:
			if AvlTree._is_left(node):
				node.parent.left = None
			else:
				node.parent.right = None
			self._rebalance(node.parent)
		else:
			self._tree = None
		node.parent = None
		node.left = None
		node.right = None

	def remove(self, k):
		node = self._get_node(k)
		if not node:
			return
		if AvlTree._is_leaf(node):
			self._remove_leaf(node)
			return
		if node.left and node.right:
			nxt = AvlTree._get_next(node)
			node.key = nxt.key
			node.value = nxt.value
			if self._is_leaf(nxt):
				self._remove_leaf(nxt)
			else:
				self._remove_one(nxt)
			self._rebalance(node)
		else:
			self._remove_one(node)

	def get(self, k):
		node = self._get_node(k)
		return node.value if node else -1

	def _get_node(self, k):
		if not self._tree:
			return None
		node = self._tree
		while node:
			if k < node.key:
				node = node.left
			elif node.key < k:
				node = node.right
			else:
				return node
		return None

	def get_at(self, pos):
		x = pos + 1
		node = self._tree
		while node:
			if x < node.num_left:
				node = node.left
			elif node.num_left < x:
				x -= node.num_left
				node = node.right
			else:
				return (node.key, node.value)
		raise IndexError('Out of ranges')

	@staticmethod
	def _is_left(node):
		return node.parent.left and node.parent.left == node

	@staticmethod
	def _is_leaf(node):
		return node.left is None and node.right is None

	def _rotate_right(self, node):
		if not node.parent:
			self._tree = node.left
			node.left.parent = None
		elif AvlTree._is_left(node):
			node.parent.left = node.left
			node.left.parent = node.parent
		else:
			node.parent.right = node.left
			node.left.parent = node.parent
		bk = node.left.right
		node.left.right = node
		node.parent = node.left
		node.left = bk
		if bk:
			bk.parent = node
		node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
		node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
		node.num_left = 1 + self.get_num_total(node.left)

	def _rotate_left(self, node):
		if not node.parent:
			self._tree = node.right
			node.right.parent = None
		elif AvlTree._is_left(node):
			node.parent.left = node.right
			node.right.parent = node.parent
		else:
			node.parent.right = node.right
			node.right.parent = node.parent
		bk = node.right.left
		node.right.left = node
		node.parent = node.right
		node.right = bk
		if bk:
			bk.parent = node
		node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
		node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
		node.num_left = 1 + self.get_num_total(node.left)

	@staticmethod
	def _get_next(node):
		if not node.right:
			return node.parent
		n = node.right
		while n.left:
			n = n.left
		return n

class SegmentTree1:

	def __init__(self, data, default=2 ** 30, func=lambda a, b: min(a, b)):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class SegmentTree:

	def __init__(self, data, default=0, func=lambda a, b: a + b):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class Factorial:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorials = [1, 1]
		self.invModulos = [0, 1]
		self.invFactorial_ = [1, 1]

	def calc(self, n):
		if n <= -1:
			print('Invalid argument to calculate n!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.factorials):
			return self.factorials[n]
		nextArr = [0] * (n + 1 - len(self.factorials))
		initialI = len(self.factorials)
		prev = self.factorials[-1]
		m = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * i % m
		self.factorials += nextArr
		return self.factorials[n]

	def inv(self, n):
		if n <= -1:
			print('Invalid argument to calculate n^(-1)')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		p = self.MOD
		pi = n % p
		if pi < len(self.invModulos):
			return self.invModulos[pi]
		nextArr = [0] * (n + 1 - len(self.invModulos))
		initialI = len(self.invModulos)
		for i in range(initialI, min(p, n + 1)):
			next = -self.invModulos[p % i] * (p // i) % p
			self.invModulos.append(next)
		return self.invModulos[pi]

	def invFactorial(self, n):
		if n <= -1:
			print('Invalid argument to calculate (n^(-1))!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.invFactorial_):
			return self.invFactorial_[n]
		self.inv(n)
		nextArr = [0] * (n + 1 - len(self.invFactorial_))
		initialI = len(self.invFactorial_)
		prev = self.invFactorial_[-1]
		p = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * self.invModulos[i % p] % p
		self.invFactorial_ += nextArr
		return self.invFactorial_[n]

class Combination:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorial = Factorial(MOD)

	def ncr(self, n, k):
		if k < 0 or n < k:
			return 0
		k = min(k, n - k)
		f = self.factorial
		return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD

def powm(a, n, m):
	if a == 1 or n == 0:
		return 1
	if n % 2 == 0:
		s = powm(a, n // 2, m)
		return s * s % m
	else:
		return a * powm(a, n - 1, m) % m

def sort_list(list1, list2):
	zipped_pairs = zip(list2, list1)
	z = [x for (_, x) in sorted(zipped_pairs)]
	return z

def product(l):
	por = 1
	for i in range(len(l)):
		por *= l[i]
	return por

def binarySearchCount(arr, n, key):
	left = 0
	right = n - 1
	count = 0
	while left <= right:
		mid = int((right + left) / 2)
		if arr[mid] < key:
			count = mid + 1
			left = mid + 1
		else:
			right = mid - 1
	return count

def countdig(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def binary(x, length):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y

def countGreater(arr, n, k):
	l = 0
	r = n - 1
	leftGreater = n
	while l <= r:
		m = int(l + (r - l) / 2)
		if arr[m] > k:
			leftGreater = m
			r = m - 1
		else:
			l = m + 1
	return n - leftGreater

class TrieNode:

	def __init__(self):
		self.children = [None] * 26
		self.isEndOfWord = False

class Trie:

	def __init__(self):
		self.root = self.getNode()

	def getNode(self):
		return TrieNode()

	def _charToIndex(self, ch):
		return ord(ch) - ord('a')

	def insert(self, key):
		pCrawl = self.root
		length = len(key)
		for level in range(length):
			index = self._charToIndex(key[level])
			if not pCrawl.children[index]:
				pCrawl.children[index] = self.getNode()
			pCrawl = pCrawl.children[index]
		pCrawl.isEndOfWord = True

	def search(self, key):
		pCrawl = self.root
		length = len(key)
		for level in range(length):
			index = self._charToIndex(key[level])
			if not pCrawl.children[index]:
				return False
			pCrawl = pCrawl.children[index]
		return pCrawl != None and pCrawl.isEndOfWord

class Node:

	def __init__(self, data):
		self.data = data
		self.count = 0
		self.left = None
		self.right = None

class BinaryTrie:

	def __init__(self):
		self.root = Node(0)

	def insert(self, pre_xor):
		self.temp = self.root
		for i in range(31, -1, -1):
			val = pre_xor & 1 << i
			if val:
				if not self.temp.right:
					self.temp.right = Node(0)
				self.temp = self.temp.right
				self.temp.count += 1
			if not val:
				if not self.temp.left:
					self.temp.left = Node(0)
				self.temp = self.temp.left
				self.temp.count += 1
		self.temp.data = pre_xor

	def query(self, xor):
		self.temp = self.root
		for i in range(31, -1, -1):
			val = xor & 1 << i
			if not val:
				if self.temp.left and self.temp.left.count > 0:
					self.temp = self.temp.left
				elif self.temp.right:
					self.temp = self.temp.right
			elif self.temp.right and self.temp.right.count > 0:
				self.temp = self.temp.right
			elif self.temp.left:
				self.temp = self.temp.left
			self.temp.count -= 1
		return xor ^ self.temp.data
n = int(input())
s = input()
t = input()
d1 = defaultdict(chr)
d = defaultdict(int)
for i in range(97, 123):
	d[chr(i)] = i - 97
	d1[i - 97] = chr(i)
carry = 0
ans = deque([])
for i in range(n - 1, -1, -1):
	su = carry + d[s[i]] + d[t[i]]
	ans.appendleft(d1[su % 26])
	carry = su // 26
if carry != 0:
	ans.appendleft(d1[carry])
rem = 0
fi = []
for i in range(len(ans)):
	qu = (rem * 26 + d[ans[i]]) // 2
	rem = d[ans[i]] % 2
	if i == 0 and qu == 0 and (d[s[i]] != 0):
		continue
	fi.append(d1[qu])
print(*fi, sep='')


k = int(input())
s1 = input()
s2 = input()
a1 = []
a2 = []
delta = []
for i in range(k):
	a1.append(ord(s1[i]) - 97)
	a2.append(ord(s2[i]) - 97)
	delta.append(a2[i] + a1[i])
for i in range(k - 1):
	delta[i + 1] += 26 * (delta[i] % 2)
	delta[i] = delta[i] // 2
delta[k - 1] = delta[k - 1] // 2
i = k - 1
while i > 0:
	if delta[i] >= 26:
		delta[i - 1] += 1
		delta[i] -= 26
	else:
		i -= 1
for i in range(k):
	print(chr(delta[i] + 97), end='')


import sys
from bisect import bisect_left, bisect_right
from collections import deque, Counter
from math import gcd, sqrt, factorial, ceil, log
from itertools import permutations
inf = float('inf')
mod = 1000000007
mini = 1000000007

def fact(n):
	if n == 0:
		return 1
	p = 1
	d = 10 ** 9 + 7
	for i in range(1, n + 1):
		p = p * i
		p = p % d
	return p

def ncr(n, r):
	d = 10 ** 9 + 7
	num = fact(n)
	den = fact(r) * fact(n - r) % d
	den = pow(den, d - 2, d)
	return num * den % d

def sieve(n):
	prime = [True for i in range(n + 1)]
	lst = [0] * (n + 1)
	p = 2
	while p * p <= n:
		if prime[p]:
			lst[p] = p
			for i in range(p * p, n + 1, p):
				if prime[i] == True:
					prime[i] = False
					lst[i] = p
		p = p + 1
	for i in range(1, n + 1):
		if lst[i] == 0:
			lst[i] = i
	mylist = [0] * (n + 1)
	for i in range(2, n + 1):
		mylist[lst[i]] = mylist[lst[i]] + 1
	return mylist

def binary(number):
	result = 0
	while number:
		result = result + 1
		number = number & number - 1
	return result

def calculate_factors(n):
	hh = [1] * (n + 1)
	p = 2
	while p * p < n:
		if hh[p] == 1:
			for i in range(p * 2, n, p):
				hh[i] = 0
		p += 1
	total = 1
	for p in range(2, n + 1):
		if hh[p] == 1:
			count = 0
			if n % p == 0:
				while n % p == 0:
					n = int(n / p)
					count += 1
				total *= count + 1
	return total

def prime_factors(n):
	i = 2
	factors = set()
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.add(i)
	if n > 1:
		factors.add(n)
	if len(factors) == 2:
		return True
	else:
		return False

def isPrime(n):
	if n == 2 or n == 3:
		return True
	if n % 2 == 0 or n < 2:
		return False
	for i in range(3, int(n ** 0.5) + 1, 2):
		if n % i == 0:
			return False
	return True

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

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

def input():
	return sys.stdin.readline().strip()
n = int(input())
A = [ord(c) - 97 for c in input()]
B = [ord(c) - 97 for c in input()]
C = [a + b for (a, b) in zip(A, B)]
D = [0] * n
for i in range(n):
	if C[i] & 1:
		D[i + 1] += 13
	D[i] += C[i] // 2
for i in reversed(range(n)):
	while D[i] >= 26:
		D[i - 1] += 1
		D[i] -= 26
print(*[chr(d + 97) for d in D], sep='')


def main():
	k = int(input())
	s = list(reversed(input()))
	t = list(reversed(input()))
	st = [0] * (k + 1)
	carry = 0
	for pos in range(0, k):
		s_pos = ord(s[pos]) - ord('a')
		t_pos = ord(t[pos]) - ord('a')
		total = s_pos + t_pos + carry
		carry = total // 26
		total %= 26
		st[pos] = total
	st[k] = carry
	st = list(reversed(st))
	for pos in range(0, len(st)):
		rem = st[pos] % 2
		st[pos] //= 2
		if pos < len(st) - 1:
			st[pos + 1] += rem * 26
		else:
			assert rem == 0
	print(''.join([chr(st[pos] + ord('a')) for pos in range(1, len(st))]))
main()


from itertools import accumulate
(n, s, t) = (int(input()), input(), input())
a = [0] + [ord(s[i]) + ord(t[i]) - (ord('a') << 1) for i in range(n)]
for i in range(n, -1, -1):
	if a[i] >= 26:
		a[i] -= 26
		a[i - 1] += 1
for i in range(n, -1, -1):
	if a[i] & 1:
		a[i + 1] += 13
	a[i] >>= 1
print(''.join(map(lambda _: chr(ord('a') + _), a[1:])))


def arr(ls):
	l = [0] * len(ls)
	for (i, v) in enumerate(ls):
		l[i] = ord(v) - 97
	return l

def div2(ls, n):
	carry = 0
	for i in range(n):
		rem = ls[i] % 2 == 1
		ls[i] = ls[i] // 2 + carry
		if rem:
			carry = 13
		else:
			carry = 0
	return ls

def subtr(ls1, ls2, n):
	carry = 0
	for i in range(n - 1, -1, -1):
		ls1[i] -= carry
		carry = int(ls1[i] < ls2[i])
		ls1[i] = (ls1[i] - ls2[i]) % 26
	return ls1

def add(ls1, ls2, n):
	for i in range(n - 1, -1, -1):
		ls1[i] += ls2[i]
		if ls1[i] > 25:
			ls1[i - 1] += 1
			ls1[i] -= 26
	return ls1
import io, os
kk = lambda : map(int, input().split())
k2 = lambda : map(lambda x: int(x) - 1, input().split())
ll = lambda : list(kk())
(n, w1, w2) = (int(input()), list(input().strip()), list(input().strip()))
(ls1, ls2) = (arr(w1), arr(w2))
subtr(ls2, ls1, n)
div2(ls2, n)
add(ls1, ls2, n)
print(''.join(map(lambda x: chr(97 + x), [x for x in ls1])))


BASE = 26

def str2num(s):
	return [ord(x) - ord('a') for x in reversed(s)]

def num2str(number):
	return ''.join((chr(x + ord('a')) for x in number))

def add(x, y):
	k = len(x)
	result = [0] * (k + 1)
	memory = 0
	for i in range(k):
		(memory, result[i]) = divmod(x[i] + y[i] + memory, BASE)
	result[-1] = memory
	return result

def div(x):
	k = len(x)
	result = [0] * k
	carry = 0
	for i in range(k - 1, -1, -1):
		current = x[i] + carry * BASE
		(result[i], carry) = divmod(current, 2)
	return result[::-1][1:]

def main():
	_ = int(input())
	x = str2num(input())
	y = str2num(input())
	print(num2str(div(add(x, y))))
main()


def to_cc26(s):
	result = [ord(v) - ord('a') for v in s]
	result.reverse()
	return result

def to_number(a):
	result = 0
	mult = 1
	for v in a:
		result += v * mult
		mult *= 26
	return result

def minus(b, a):
	index = 0
	result = []
	additional = 0
	while index < len(b):
		if b[index] >= a[index] + additional:
			result.append(b[index] - a[index] - additional)
			additional = 0
		else:
			result.append(b[index] + 26 - a[index] - additional)
			additional = 1
		index += 1
	return result

def plus(a, b):
	index = 0
	result = []
	additional = 0
	while index < len(a):
		if b[index] + a[index] + additional < 26:
			result.append(b[index] + a[index] + additional)
			additional = 0
		else:
			result.append(b[index] + a[index] + additional - 26)
			additional = 1
		index += 1
	return result

def to_str(a):
	a.reverse()
	return ''.join((chr(v + ord('a')) for v in a))

def divide_2(a):
	a.reverse()
	result = []
	index = 0
	value = 0
	while index < len(a):
		value = value * 26 + a[index]
		result.append(value // 2)
		value %= 2
		index += 1
	result.reverse()
	return result

def solve(s, t):
	b = to_cc26(t)
	a = to_cc26(s)
	diff_26 = minus(b, a)
	half_diff = divide_2(diff_26)
	result_26 = plus(a, half_diff)
	return to_str(result_26)

def main() -> None:
	n = int(input())
	s = input()
	t = input()
	print(solve(s, t))
main()


def next_int():
	return int(input())

def next_int_list():
	return [int(i) for i in input().split(' ')]

def next_float():
	return float(input())

def next_float_list():
	return [int(i) for i in input().split(' ')]

def next_string():
	return input()

def print_int_list(l):
	print(' '.join([str(i) for i in l]))
n = next_int()
s = next_string()
t = next_string()
orda = ord('a')
base = 26
s = [ord(c) - orda for c in s]
t = [ord(c) - orda for c in t]
num = [0 for i in range(n + 1)]
acc = 0
for i in range(n - 1, -1, -1):
	summ = s[i] + t[i] + acc
	if summ >= base:
		summ -= base
		acc = 1
	else:
		acc = 0
	num[i + 1] = summ
num[0] = acc
acc = 0
for i in range(n + 1):
	d = num[i] + acc
	if d % 2 == 1:
		acc = base
	else:
		acc = 0
	num[i] = d // 2
num = ''.join([chr(i + orda) for i in num[1:]])
print(num)


from sys import stdin

def ip():
	return [int(i) for i in stdin.readline().split()]

def sp():
	return [str(i) for i in stdin.readline().split()]

def pp(A):
	for i in A:
		print(i)

def solve():
	n = int(input())
	s = [0] + list(str(input()))
	t = [0] + list(str(input()))
	for i in range(1, n + 1):
		s[i] = ord(s[i]) - 97
		t[i] = ord(t[i]) - 97
	for i in range(len(s) - 1, -1, -1):
		s[i] += t[i]
		if i != 0:
			s[i - 1] += s[i] // 26
			s[i] %= 26
	for i in range(n + 1):
		r = s[i] % 2
		s[i] /= 2
		if i != n:
			s[i + 1] += r * 26
		if i == 0:
			continue
		print(chr(int(s[i] + 97)), end='')
	return 0
solve()


n = int(input())
s = input()
t = input()
c = ord('a')
l = [0 for i in range(n)]
for i in range(n):
	l[-1 - i] += ord(s[i]) - c + 1
	l[-1 - i] += ord(t[i]) - c + 1
for i in range(n - 1, -1, -1):
	if l[i] % 2 and i != 0:
		l[i - 1] += 26
	l[i] = l[i] // 2
for i in range(0, n):
	if l[i] > 26:
		l[i] -= 26
		l[i + 1] += 1
ans = ''
for i in range(n - 1, -1, -1):
	ans += chr(ord('a') + l[i] - 1)
print(ans)


n = int(input(''))
a = input('')
b = input('')
c = [0 for _ in range(n + 1)]
for i in range(n - 1, -1, -1):
	aa = ord(a[i]) - ord('a')
	bb = ord(b[i]) - ord('a')
	c[i + 1] += aa + bb
	if c[i + 1] >= 26:
		c[i] += c[i + 1] // 26
		c[i + 1] %= 26

def show_str(l):
	out = ''
	for item in l:
		out += item
	print(out)
carry_over = False
for i in range(0, n + 1):
	if carry_over:
		c[i] += 26
	carry_over = c[i] % 2 == 1
	c[i] = c[i] // 2
	c[i] = chr(ord('a') + c[i])
show_str(c[1:])


k = int(input())
s = input()
t = input()
val = [0 for i in range(0, k)]
nval = [0 for i in range(0, k)]
for i in range(0, k):
	val[i] = ord(s[i]) - ord('a') + ord(t[i]) - ord('a')
ans = ['a' for i in range(0, k)]
carry = 0
for i in range(0, k):
	ncarry = 0
	t = val[i] // 2 + carry
	if val[i] % 2 == 1:
		ncarry += 13
	nval[i] = t
	carry = ncarry
for i in range(k - 1, -1, -1):
	if nval[i] >= 26:
		nval[i - 1] += nval[i] // 26
		nval[i] %= 26
	ans[i] = chr(ord('a') + nval[i])
print(''.join((x for x in ans)))


from string import ascii_lowercase
k = int(input())
(s, t) = (input(), input())
out = []
carry = 0
for (c, d) in zip(reversed(s), reversed(t)):
	x = ord(c) - ord('a')
	y = ord(d) - ord('a')
	total = x + y + carry
	(carry, total) = divmod(total, 26)
	out.append(chr(total + ord('a')))
out.append(chr(carry + ord('a')))
out2 = []
carry = 0
for c in out:
	x = ord(c) - ord('a')
	total = x * 13 + carry
	(carry, total) = divmod(total, 26)
	out2.append(chr(total + ord('a')))
out2.append(chr(carry + ord('a')))
while len(out2) >= k + 2:
	out2.pop()
out2 = out2[::-1]
out2.pop()
print(*out2, sep='')


n = int(input())
s = input()
t = input()

def f(x):
	return ord(x) - ord('a')

def g(x):
	return chr(x + ord('a'))
A = []
for i in range(n):
	A.append(f(s[i]) + f(t[i]))
for i in range(n - 1, 0, -1):
	if A[i] // 26:
		A[i - 1] += 1
		A[i] %= 26
for i in range(n):
	if A[i] % 2:
		A[i + 1] += 26
		A[i] -= 1
	A[i] //= 2
for i in A:
	print(g(i), end='')
print()


def b26sub(a, b, n, c):
	for i in range(n - 1, -1, -1):
		if a[i] > b[i]:
			b[i] += 26
			b[i - 1] -= 1
		c[i] = b[i] - a[i]

def b26add(a, b, n, c):
	car = 0
	for i in range(n - 1, -1, -1):
		x = a[i] + b[i] + car
		car = x // 26
		c[i] = x % 26

def b26div2(a, n, c):
	rem = 0
	for i in range(n):
		cur = rem * 26 + a[i]
		c[i] = cur // 2
		rem = cur % 2
n = int(input())
s = input()
t = input()
a = []
b = []
c = []
d = []
e = []
for i in range(n):
	c.append(0)
	d.append(0)
	e.append(0)
	a.append(ord(s[i]) - ord('a'))
	b.append(ord(t[i]) - ord('a'))
b26sub(a, b, n, c)
b26div2(c, n, d)
b26add(a, d, n, e)
l = ''
for i in range(n):
	l += chr(e[i] + ord('a'))
print(l)


k = int(input())
a = reversed(input())
b = reversed(input())
aa = [0] * (k + 1)
bb = [0] * (k + 1)
for (i, x) in enumerate(a):
	aa[i] = ord(x) - 97
for (i, x) in enumerate(b):
	bb[i] = ord(x) - 97
carry = 0
cc = [0] * (k + 1)
for i in range(k + 1):
	cc[i] = aa[i] + bb[i] + carry
	if cc[i] >= 26:
		carry = 1
		cc[i] -= 26
	else:
		carry = 0
carry = 0
for i in reversed(range(k + 1)):
	value = carry * 26 + cc[i]
	carry = value % 2
	cc[i] = value // 2
answer = ''
for x in reversed(cc[:-1]):
	answer += chr(x + 97)
print(answer)


import math
import bisect

def egcd(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		(g, x, y) = egcd(b % a, a)
		return (g, y - b // a * x, x)

def mulinv(b, n):
	(g, x, _) = egcd(b, n)
	if g == 1:
		return x % n
primes = []

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

def argsort(ls):
	return sorted(range(len(ls)), key=ls.__getitem__)

def f(p=0):
	if p == 1:
		return map(int, input().split())
	elif p == 2:
		return list(map(int, input().split()))
	else:
		return int(input())
n = f()
s = input()
t = input()
a = 0
b = 0
p = ord('a')
res = ''
cl = []
ost = 0
for i in range(n - 1, -1, -1):
	x = ord(s[i]) + ord(t[i]) + ost - 2 * p
	if x >= 26:
		cl.append(x % 26)
		ost = x // 26
	else:
		cl.append(x)
		ost = 0
if ost != 0:
	cl.append(ost)
cl = cl[::-1]
res = []
ost = 0
for i in range(len(cl)):
	k = ost * 26 + cl[i]
	if k >= 2:
		res.append(k // 2)
		ost = k % 2
	else:
		if res != []:
			res.append(0)
		ost = k
ln = len(res)
res = [0] * (n - ln) + res
ans = ''
for x in res:
	ans += chr(x + p)
print(ans)


from sys import stdin, stdout, setrecursionlimit
input = stdin.readline
import string
characters = string.ascii_lowercase
inf = float('inf')
from functools import cmp_to_key
from collections import defaultdict as dd
from collections import Counter, deque
from heapq import *
import math
from math import floor, ceil, sqrt

def geti():
	return map(int, input().strip().split())

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

def getis():
	return map(str, input().strip().split())

def getls():
	return list(map(str, input().strip().split()))

def gets():
	return input().strip()

def geta():
	return int(input())

def print_s(s):
	stdout.write(s + '\n')

def solve():
	n = geta()
	s = list(gets())
	t = list(gets())
	ans = ''
	alpha = {characters[i]: i for i in range(26)}
	for i in range(n):
		s[i] = alpha[s[i]]
		t[i] = alpha[t[i]]
	for i in range(n - 1, -1, -1):
		s[i] += t[i]
		if s[i] >= 26 and i:
			s[i - 1] += 1
			s[i] %= 26
	for i in range(n):
		if s[i] & 1 and i + 1 < n:
			s[i + 1] += 26
		s[i] //= 2
	for i in range(n):
		ans += characters[s[i]]
	print(ans)
solve()


import sys
import math
from collections import defaultdict, deque
import heapq

def convertto26(num, k):
	ans = []
	while num > 0:
		ans.append(num % 26)
		num //= 26
	n = len(ans)
	if n < k:
		for i in range(n, k):
			ans.append(0)
	ans.reverse()
	return ans

def convertto10(s):
	num = 0
	n = len(s)
	ans = 0
	for i in range(n):
		ans *= 26
		ans += ord(s[i]) - 97
	return ans
mul = []
for i in range(26):
	if i * 2 >= 26:
		mul.append(convertto26(i * 2, 2))
	else:
		mul.append(convertto26(i * 2, 1))
k = int(sys.stdin.readline())
s1 = sys.stdin.readline()[:-1]
s2 = sys.stdin.readline()[:-1]
l1 = []
l2 = []
for i in range(k):
	l1.append(ord(s1[i]) - 97)
	l2.append(ord(s2[i]) - 97)
add = []
carry = 0
for i in range(k - 1, -1, -1):
	cur = carry + l1[i] + l2[i]
	carry = cur // 26
	add.append(cur % 26)
if carry > 0:
	add.append(carry)
add.reverse()
div = []
cur = 0
s = 0
for i in range(len(add)):
	s += add[i]
	if s == 0:
		div.append(s)
	else:
		ind = -1
		for j in range(26):
			if 2 * j <= s:
				ind = j
		div.append(ind)
		s -= 2 * ind
		s *= 26
st = 0
for i in range(len(div)):
	if div[i] == 0:
		st += 1
	else:
		break
ans = []
cnt = 0
for i in range(len(div) - 1, len(div) - k - 1, -1):
	ans.append(chr(div[i] + 97))
ans.reverse()
print(''.join((x for x in ans)))


import math
from string import ascii_lowercase as ascii

def get_big_num(s):
	res = [None] * len(s)
	for i in range(len(s)):
		res[i] = ord(s[i]) - ord('a')
	return res

def median(n, s1, s2):
	num1 = get_big_num(s1)
	num2 = get_big_num(s2)
	res = [None] * n
	for i in range(n - 1, -1, -1):
		res[i] = num1[i] + num2[i]
		if i > 0:
			(div, res[i]) = divmod(res[i], 26)
			num1[i - 1] += div
	for i in range(n):
		(res[i], mod) = divmod(res[i], 2)
		if i != n - 1:
			res[i + 1] += mod * 26
	median = [None] * n
	for i in range(n):
		median[i] = chr(res[i] + ord('a'))
	return ''.join(median)
n = int(input())
str1 = input()
str2 = input()
print(median(n, str1, str2))


length = int(input())
start = input()
slist = [ord(char) - 97 for char in start]
end = input()
elist = [ord(char) - 97 for char in end]
result = []
weirdnumber = 0
for i in range(0, length, 1):
	dif = (elist[i] + slist[i]) / 2 + weirdnumber
	weirdnumber = 0
	if int(dif) != dif:
		result.append(int(dif))
		weirdnumber = 13
	else:
		result.append(int(dif))
for i in range(length - 1, -1, -1):
	if result[i] >= 26:
		r = result[i] // 26
		result[i] -= r * 26
		result[i - 1] += r
actualresult = ''
for char in result:
	thing = chr(97 + char)
	if thing == '{':
		actualresult += 'a'
	else:
		actualresult += chr(97 + char)
print(actualresult)


def stringToBase(string, K):
	base = []
	for i in range(0, K):
		base += [ord(string[i]) - ord('a')]
	return base

def getMedian(stringA, stringB, K):
	baseA = stringToBase(stringA, K)
	baseB = stringToBase(stringB, K)
	baseResult = []
	for i in range(0, K):
		baseResult += [0]
	for i in range(0, K):
		index = K - i - 1
		baseResult[index] += baseA[index] + baseB[index]
		if baseResult[index] >= 26 and index > 0:
			baseResult[index] -= 26
			baseResult[index - 1] += 1
	for i in range(0, K):
		if i != K - 1:
			baseResult[i + 1] += 26 * (baseResult[i] % 2)
		baseResult[i] = int(baseResult[i] / 2)
	stringMedian = ''
	for i in range(0, K):
		stringMedian += chr(ord('a') + baseResult[i])
	return stringMedian
K = int(input())
S = input()
T = input()
print(getMedian(S, T, K))


n = int(input())
a = list(input())
b = list(input())
num_a = [ord(i) - 97 for i in a]
num_b = [ord(i) - 97 for i in b]
num = [0 for i in range(n)]
carry = 0
for i in range(n - 1, -1, -1):
	if i == 0:
		num[i] = num_a[i] + num_b[i] + carry
		continue
	add = num_a[i] + num_b[i] + carry
	carry = add // 26
	num[i] = add % 26
carry = 0
for i in range(n):
	num[i] += carry
	carry = num[i] % 2 * 26
	num[i] //= 2
	print(chr(num[i] + 97), end='')


letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
k = int(input())
s = input()
t = input()
med = [0 for i in range(k)]
for i in range(k):
	tem = (letters.index(t[k - 1 - i]) + letters.index(s[k - 1 - i])) / 2
	med[k - 1 - i] = med[k - 1 - i] + int(tem)
	if tem > int(tem):
		med[k - 1 - i + 1] = med[k - 1 - i + 1] + 13
		if med[k - 1 - i + 1] > 25:
			med[k - 1 - i + 1] -= 26
			med[k - 1 - i] += 1
	if med[k - 1 - i] > 25:
		med[k - 1 - i] -= 26
		med[k - 1 - i - 1] += 1
printout = ''
for i in range(k):
	printout += letters[med[i]]
print(printout)


from typing import List, Tuple
import sys
DEBUG = len(sys.argv) > 1 and sys.argv[1] == '-d'

def LOG(*argv):
	if DEBUG:
		print(*argv, file=sys.stderr)

def CHECK(cond, err_msg=''):
	if DEBUG:
		assert cond, err_msg

def CHECK_EQ(a, b, err_msg=''):
	CHECK(a == b, err_msg='{} v.s. {} {}'.format(a, b, err_msg))

def readval(typ=int):
	return typ(input())

def readvals(typ=int):
	return list(map(typ, input().split()))

def c2i(c: str) -> int:
	return ord(c) - ord('a')

def i2c(i: int) -> str:
	return chr(i + ord('a'))

def solve(k: int, s: str, t: str) -> str:
	(sum_val, carry) = ([], 0)
	for i in reversed(range(k)):
		cur_digit = c2i(s[i]) + c2i(t[i]) + carry
		carry = cur_digit // 26
		cur_digit %= 26
		sum_val.append(cur_digit)
	sum_val.append(carry)
	sum_val.reverse()
	reminder = 0
	median_digits = []
	for i in range(k + 1):
		div = reminder * 26 + sum_val[i]
		digit = div // 2
		reminder = div % 2
		median_digits.append(digit)
	return ''.join(map(i2c, median_digits[1:]))
CHECK_EQ(solve(2, 'az', 'bf'), 'bc')
CHECK_EQ(solve(5, 'afogk', 'asdji'), 'alvuw')
CHECK_EQ(solve(6, 'nijfvj', 'tvqhwp'), 'qoztvz')
(k, s, t) = (readval(), readval(str), readval(str))
print(solve(k, s, t))


n = int(input())
ss = input()
s = ss[::-1]
t = input()[::-1]
tt = [0] * n
for i in range(n):
	c = ord(s[i]) - ord('a')
	tt[i] = ord(t[i]) - ord('a')
	tt[i] -= c
for i in range(n - 1):
	if tt[i] < 0:
		tt[i] += 26
		tt[i + 1] -= 1
tt = tt[::-1]
rem = 0
for i in range(n):
	rem = rem * 26 + tt[i]
	tt[i] = rem // 2
	rem = rem % 2
res = [x for x in ss]
for i in range(n - 1, -1, -1):
	c = tt[i] + ord(res[i]) - ord('a')
	tt[i] = c % 26
	if i > 0:
		tt[i - 1] += c // 26
	res[i] = chr(tt[i] + ord('a'))
print(''.join(res))


import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
N = int(input())
S = [ord(c) - ord('a') for c in input()[:-1]]
T = [ord(c) - ord('a') for c in input()[:-1]]
ans = []
p = N - 1
bemp = S[p] + T[p]
while p > 0:
	p -= 1
	bemp += (S[p] + T[p]) * 26
	ans.append(chr(bemp // 2 % 26 + ord('a')))
	bemp //= 26
ans.append(chr(bemp // 2 % 26 + ord('a')))
print(''.join(map(str, reversed(ans))))


n = int(input())
a = [ord(c) - 97 for c in input()]
b = [ord(c) - 97 for c in input()]
ans = []
p = n - 1
bemp = b[p] + a[p]
while p > 0:
	p -= 1
	bemp += (b[p] + a[p]) * 26
	ans.append(chr(int(bemp / 2) % 26 + 97))
	bemp //= 26
ans.append(chr(int(bemp / 2) % 26 + 97))
p = n
while p:
	p -= 1
	print(ans[p], end='')


def array_of(f, *dim):
	return [array_of(f, *dim[1:]) for _ in range(dim[0])] if dim else f()

def atoi(c):
	return ord(c) - ord('a')

def itoa(i):
	return chr(i + ord('a'))
n = int(input())
(s, t) = (input(), input())
s = list(map(atoi, reversed(s)))
t = list(map(atoi, reversed(t)))
ss = array_of(int, n + 1)
for i in range(n):
	x = s[i] + t[i]
	if ss[i] + x >= 26:
		ss[i] += x - 26
		ss[i + 1] += 1
	else:
		ss[i] += x
for i in range(n + 1 - 1, -1, -1):
	if ss[i] % 2 == 1:
		ss[i - 1] += 26
	ss[i] //= 2
out = []
for i in range(n - 1, -1, -1):
	out.append(itoa(ss[i]))
print(''.join(out))


import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

class SegmentTree:

	def __init__(self, data, default=-10 ** 6, func=lambda a, b: max(a, b)):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class SegmentTree1:

	def __init__(self, data, default=10 ** 6, func=lambda a, b: min(a, b)):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)
MOD = 10 ** 9 + 7

class Factorial:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorials = [1, 1]
		self.invModulos = [0, 1]
		self.invFactorial_ = [1, 1]

	def calc(self, n):
		if n <= -1:
			print('Invalid argument to calculate n!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.factorials):
			return self.factorials[n]
		nextArr = [0] * (n + 1 - len(self.factorials))
		initialI = len(self.factorials)
		prev = self.factorials[-1]
		m = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * i % m
		self.factorials += nextArr
		return self.factorials[n]

	def inv(self, n):
		if n <= -1:
			print('Invalid argument to calculate n^(-1)')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		p = self.MOD
		pi = n % p
		if pi < len(self.invModulos):
			return self.invModulos[pi]
		nextArr = [0] * (n + 1 - len(self.invModulos))
		initialI = len(self.invModulos)
		for i in range(initialI, min(p, n + 1)):
			next = -self.invModulos[p % i] * (p // i) % p
			self.invModulos.append(next)
		return self.invModulos[pi]

	def invFactorial(self, n):
		if n <= -1:
			print('Invalid argument to calculate (n^(-1))!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.invFactorial_):
			return self.invFactorial_[n]
		self.inv(n)
		nextArr = [0] * (n + 1 - len(self.invFactorial_))
		initialI = len(self.invFactorial_)
		prev = self.invFactorial_[-1]
		p = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * self.invModulos[i % p] % p
		self.invFactorial_ += nextArr
		return self.invFactorial_[n]

class Combination:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorial = Factorial(MOD)

	def ncr(self, n, k):
		if k < 0 or n < k:
			return 0
		k = min(k, n - k)
		f = self.factorial
		return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod = 10 ** 9 + 7
omod = 998244353
prime = [True for i in range(50001)]
pp = []

def SieveOfEratosthenes(n=50000):
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	for i in range(50001):
		if prime[i]:
			pp.append(i)
n = int(input())
s = list(input())
t = list(input())
for i in range(n):
	s[i] = ord(s[i]) - 97
	t[i] = ord(t[i]) - 97
a = [0] * n
carry = 0
for i in range(n - 1, -1, -1):
	if i == 0:
		a[i] = s[i] + t[i] + carry
	else:
		sm = s[i] + t[i] + carry
		carry = sm // 26
		a[i] = sm % 26
carry = 0
for i in range(n):
	a[i] += carry
	carry = a[i] % 2 * 26
	a[i] //= 2
	print(chr(a[i] + 97), end='')


n = int(input())
s = input()
t = input()
import string
l_alp = string.ascii_lowercase
d = dict(zip(l_alp, range(26)))
mm = [d[s[i]] + d[t[i]] for i in range(n)]
for i in range(n):
	x = mm[i]
	if x % 2 == 0:
		mm[i] //= 2
	else:
		mm[i] //= 2
		mm[i + 1] += 26
for i in range(n)[::-1]:
	if mm[i] >= 26:
		mm[i - 1] += mm[i] // 26
		mm[i] %= 26
print(''.join([chr(i + 97) for i in mm]))


I = input
(k, s, t) = (int(I()), I(), I())
answer = [''] * k
res = ord(s[-1]) + ord(t[-1]) - 194
for j in range(k - 2, -1, -1):
	res += 26 * (ord(s[j]) + ord(t[j]) - 194)
	answer[j + 1] = chr(res // 2 % 26 + 97)
	res //= 26
answer[0] = chr(res // 2 % 26 + 97)
print(''.join(answer))


from math import ceil
k = int(input())
s1 = input()
s2 = input()
so1 = []
so2 = []
for i in range(k):
	so1.append(ord(s1[i]) - ord('a'))
	so2.append(ord(s2[i]) - ord('a'))
for i in range(k - 1, -1, -1):
	so1[i] += so2[i]
	if i != 0:
		so1[i - 1] += so1[i] // 26
		so1[i] %= 26
med = ''
for i in range(k):
	v = so1[i] // 2
	if i < k - 1:
		so1[i + 1] += so1[i] % 2 * 26
	med += chr(ord('a') + v)
print(med)


k = int(input())
ALPHABET = 'abcdefghijklmnopqrstuvwxyz'
SIZE = len(ALPHABET)
ALPHABET_TO_NUMBER = dict(zip(ALPHABET, range(len(ALPHABET))))
big_sum = [ALPHABET_TO_NUMBER[l] + ALPHABET_TO_NUMBER[u] for (l, u) in zip(input(), input())]
additional = 0
for index in range(k - 1, 0, -1):
	big_sum[index] += additional
	additional = big_sum[index] // SIZE
	if big_sum[index] >= SIZE:
		big_sum[index] %= SIZE
big_sum[0] += additional
for index in range(k):
	if big_sum[index] % 2 == 1:
		big_sum[index + 1] += 26
	big_sum[index] //= 2
print(''.join([ALPHABET[number] for number in big_sum]))


from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, sin, cos, ceil, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(1000000000)
INF = float('inf')
(YES, Yes, yes, NO, No, no) = ('YES', 'Yes', 'yes', 'NO', 'No', 'no')
(dy4, dx4) = ([0, 1, 0, -1], [1, 0, -1, 0])
(dy8, dx8) = ([0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1])

def inside(y, x, H, W):
	return 0 <= y < H and 0 <= x < W

def ceil(a, b):
	return (a + b - 1) // b

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def lcm(a, b):
	g = gcd(a, b)
	return a / g * b

def euclidean_distance(y1, x1, y2, x2):
	return sqrt((y1 - y2) ** 2 + (x1 - x2) ** 2)

def manhattan_distance(y1, x1, y2, x2):
	return abs(y1 - y2) + abs(x1 - x2)

def main():
	K = int(input())
	S = input()
	T = input()
	d = [0] * K
	kari = -1
	for i in range(K):
		s = ord(S[-i - 1]) - 97
		t = ord(T[-i - 1]) - 97 - kari
		if t >= s:
			d[-i - 1] = t - s
			kari = 0
		else:
			d[-i - 1] = t + 26 - s
			kari = 1
	kari = 0
	for i in range(K):
		d[i] += kari
		if d[i] % 2 == 0:
			d[i] //= 2
			kari = 0
		else:
			d[i] //= 2
			kari = 26
	ans = [''] * K
	nex = 0
	for i in range(K):
		s = ord(S[-i - 1]) - 97 + nex
		s += d[-i - 1]
		if s < 26:
			ans[-i - 1] = chr(s + 97)
			nex = 0
		else:
			ans[-i - 1] = chr(s - 26 + 97)
			nex = 1
	print(*ans, sep='')
main()


n = int(input())
s1 = [ord(x) - 97 for x in input()]
s2 = [ord(x) - 97 for x in input()]
s12s = s1[n - 1] + s2[n - 1]
res = []
ni = n - 1
while ni > 0:
	ni -= 1
	s12s += (s1[ni] + s2[ni]) * 26
	res.append(chr(s12s // 2 % 26 + 97))
	s12s = s12s // 26
res.append(chr(s12s // 2 % 26 + 97))
ni = n
while ni > 0:
	ni -= 1
	print(res[ni], end='')
print()


k = int(input())
A = list(input())[::-1]
B = list(input())[::-1]
C = []
pivot = (ord('z') - ord('a') + 1) // 2
for i in range(k):
	(a, b) = (ord(A[i]), ord(B[i]))
	if (b - a) % 2 == 0:
		C += [chr((a + b) // 2)]
	elif ord(C[-1]) - ord('a') >= pivot:
		C[-1] = chr(ord(C[-1]) - pivot)
		C += [chr((a + b + 1) // 2)]
	else:
		C[-1] = chr(ord(C[-1]) + pivot)
		C += [chr((a + b - 1) // 2)]
print(''.join(C[::-1]))


f = lambda s: [ord(c) - ord('a') for c in s]
n = int(input())
a = f(input())
b = f(input())
c = [0]
for i in range(n - 1, -1, -1):
	c[-1] += a[i] + b[i]
	m = c[-1] // 26
	c[-1] %= 26
	c.append(m)
c.reverse()
for i in range(n + 1):
	if c[i] & 1:
		c[i + 1] += 26
	c[i] >>= 1
print(''.join((chr(ord('a') + c[i]) for i in range(1, n + 1))))


N = int(input())
s1 = [ord(i) - ord('a') for i in input()[::-1]]
s2 = [ord(i) - ord('a') for i in input()[::-1]]
res = []
temp = s1[0] + s2[0]
for i in range(1, N):
	temp += (s1[i] + s2[i]) * 26
	res.append(chr(temp // 2 % 26 + ord('a')))
	temp //= 26
res.append(chr(temp // 2 % 26 + ord('a')))
print(''.join(res[::-1]))


def main():
	n = int(input())
	s = input()
	k = input()
	arr = [0] + [ord(s[i]) + ord(k[i]) - 2 * ord('a') for i in range(n)]
	for i in range(n, -1, -1):
		if arr[i] >= 26:
			arr[i] -= 26
			arr[i - 1] += 1
	for i in range(n, -1, -1):
		if arr[i] % 2:
			arr[i + 1] += 13
		arr[i] //= 2
	for i in range(n + 1):
		arr[i] = chr(arr[i] + ord('a'))
	print(''.join(arr[1:]))
	return 0
main()


orda = ord('a')
ord0 = ord('z') - orda + 1
n = int(input())
s = input()
t = input()
sv = [ord(si) - orda for si in s]
tv = [ord(ti) - orda for ti in t]
medv = [ord(si) - orda for si in s]
for i in range(n - 1, -1, -1):
	medv[i] += tv[i]
	if i > 0 and medv[i] >= ord0:
		medv[i] -= ord0
		medv[i - 1] += 1
for i in range(n):
	if i < n - 1 and medv[i] % 2 == 1:
		medv[i + 1] += ord0
	medv[i] //= 2
ans = ''.join([chr(medvi + orda) for medvi in medv])
print(ans)


n = int(input())
s = input()
t = input()
dic = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
slis = []
tlis = []
for i in s:
	slis.append(dic.index(i))
for i in t:
	tlis.append(dic.index(i))
sumlis = []
cout = 0
for j in range(n - 1, -1, -1):
	res = slis[j] + tlis[j] + cout
	if j != 0:
		if res >= 26:
			res = res % 26
			cout = 1
		else:
			cout = 0
	sumlis.append(res)
total = sumlis[::-1]
for i in range(n):
	if total[i] % 2 == 1:
		total[i] //= 2
		total[i + 1] += 26
	else:
		total[i] //= 2
result = []
for i in total:
	result.append(dic[i])
print(''.join(result))


a = int(input())
b = [ord(i) - 97 for i in input()[::-1]]
c = [ord(i) - 97 for i in input()[::-1]]
it = b[0] + c[0]
s = []
for i in range(1, a):
	it += 26 * (b[i] + c[i])
	s.append(chr(it // 2 % 26 + 97))
	it //= 26
s.append(chr(it // 2 % 26 + 97))
s = ''.join(s[::-1])
print(s)


import sys, math, queue
sys.setrecursionlimit(1000000)
n = int(input())
a = list(input())
b = list(input())
a = [ord(ai) - 97 for ai in a]
b = [ord(bi) - 97 for bi in b]
a = [a[i] for i in range(-1, -n - 1, -1)]
b = [b[i] for i in range(-1, -n - 1, -1)]
c = [-1 for i in range(n)]
carry = 0
for i in range(n):
	if i != n - 1:
		c[i] = (carry + a[i] + b[i]) % 26
	else:
		c[i] = carry + a[i] + b[i]
	carry = (carry + a[i] + b[i]) // 26
c = [c[i] for i in range(-1, -n - 1, -1)]
carry = 0
for i in range(n):
	p = (carry * 26 + c[i]) // 2
	carry = (carry * 26 + c[i]) % 2
	c[i] = p
c = [chr(c[i] + 97) for i in range(n)]
print(''.join(c))


input()
a = input()
b = input()
x = []
y = []
for c in a:
	x.append(ord(c) - 97)
for c in b:
	y.append(ord(c) - 97)
result = [u + v for (u, v) in zip(x, y)]
for i in range(len(result) - 1, 0, -1):
	result[i - 1] += result[i] // 26
	result[i] %= 26
for (i, r) in enumerate(result):
	if r % 2 == 1:
		result[i + 1] += 26
	result[i] //= 2
r = ''.join((chr(c + 97) for c in result))
print(r)


from sys import stdin

class base:

	def __init__(self, s, base):
		(self.num, self.base) = ([0] + s, base)

	def __add__(self, other):
		out = base([0] * (max(len(other.num), len(self.num)) - 1), self.base)
		carry = 0
		for i in range(len(self.num) - 1, -1, -1):
			su = self.num[i] + other.num[i] + carry
			if su < self.base:
				(out.num[i], carry) = (su, 0)
			else:
				(out.num[i], carry) = (su % self.base, 1)
		return out

	def __truediv__(self, other):
		carry = 0
		for i in range(len(self.num)):
			cur = self.num[i] + carry * self.base
			(self.num[i], carry) = divmod(cur, other)
		return self
letters = '0123456789ABCDEFGHIJKLMNOP'
rstr = lambda : [ord(x) - 97 for x in stdin.readline().strip()]
(n, s1, t1) = (int(input()), base(rstr(), 26), base(rstr(), 26))
s1 += t1
s1 = s1 / 2
print(''.join([chr(i + 97) for i in s1.num[1:]]))


n = int(input())
a = [ord(c) - 97 for c in input()]
b = [ord(c) - 97 for c in input()]
ans = []
for i in range(n):
	sum = a[i] + b[i]
	if i + 1 < n:
		a[i + 1] += sum % 2 * 26
	sum //= 2
	ans.append(sum)
for i in range(n - 1, -1, -1):
	if i - 1 > -1:
		ans[i - 1] += ans[i] // 26
	ans[i] %= 26
ans = [chr(x + 97) for x in ans]
print(''.join(ans))


import sys
input = sys.stdin.readline
k = int(input())
s = input().rstrip()
t = input().rstrip()
ss = [ord(s[i]) - ord('a') for i in range(k)]
tt = [ord(t[i]) - ord('a') for i in range(k)]
z = [ss[i] + tt[i] for i in range(k)]
for i in range(1, k)[::-1]:
	if z[i] // 26:
		z[i] %= 26
		z[i - 1] += 1
ans = []
for i in range(k):
	if z[i] % 2:
		z[i + 1] += 26
		z[i] -= 1
	z[i] //= 2
	ans.append(chr(z[i] + ord('a')))
print(''.join(ans))


import sys

class Main:

	def __init__(self):
		self.buff = None
		self.index = 0

	def next(self):
		if self.buff is None or self.index == len(self.buff):
			self.buff = sys.stdin.readline().split()
			self.index = 0
		val = self.buff[self.index]
		self.index += 1
		return val

	def next_int(self):
		return int(self.next())

	def solve(self):
		n = self.next_int()
		a = [ord(x) - ord('a') for x in self.next()]
		b = [ord(x) - ord('a') for x in self.next()]
		c = [a[i] + b[i] for i in range(0, n)]
		for i in range(n - 1, 0, -1):
			c[i - 1] += c[i] // 26
			c[i] %= 26
		for i in range(0, n):
			if c[i] % 2 == 1 and i < n - 1:
				c[i + 1] += 26
			c[i] //= 2
		print(''.join(map(lambda x: chr(x + ord('a')), c)))
Main().solve()


def main():
	n = int(input())
	s = [ord(c) - ord('a') for c in input()]
	t = [ord(c) - ord('a') for c in input()]
	r = [s[i] + t[i] for i in range(n)]
	for i in range(n - 1, 0, -1):
		if r[i] >= 26:
			r[i] -= 26
			r[i - 1] += 1
	k = 0
	rs = [0] * n
	for i in range(n):
		b = r[i] + k
		rs[i] = chr(b // 2 + ord('a'))
		if b % 2:
			k = 26
		else:
			k = 0
	return ''.join(rs)
print(main())


n = int(input())
s = input()
t = input()
suma = [ord(s[i]) + ord(t[i]) - 194 for i in range(n)]
for i in range(n - 1):
	j = n - 1 - i
	if suma[j] > 25:
		suma[j] -= 26
		suma[j - 1] += 1
chuj = 0
if suma[0] == 26:
	chuj = 1
	suma[0] = 0
	print(chr(110), end='')
for i in range(chuj == 1, n):
	print(chr(suma[i] // 2 + 97), end='')
	if suma[i] % 2 != 0 and i < n - 1:
		suma[i + 1] += 26


k = int(input())
s = list(map(lambda x: ord(x) - ord('a'), input()))
t = list(map(lambda x: ord(x) - ord('a'), input()))
sum_ = []
old = 0
for i in reversed(range(k)):
	s_ = s[i] + t[i] + old
	new = s_ % 26
	sum_.append(new)
	old = s_ // 26
sum_.append(old)
sum_ = list(reversed(sum_))
for i in range(k + 1):
	r = sum_[i] % 2
	sum_[i] //= 2
	if i + 1 <= k:
		sum_[i + 1] += 26 * r
print(''.join(map(lambda x: chr(x + ord('a')), sum_[1:])))