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: introductory

Starter code:

Solutions:
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(list(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)



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))


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()

#Bhargey Mehta (Sophomore)
#DA-IICT, Gandhinagar
import sys, math, queue
sys.setrecursionlimit(1000000)
#sys.stdin = open("input.txt", "r")

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
#print(a)
#print(b)
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))

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)


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))

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))

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="")


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
    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]

    # Div by 2
    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)



#     tmp = 0
#     s = []
#     for c1, c2 in zip(s1, s2):
#         cur = _value(c1) + _value(c2) - tmp * 26
#         tmp = cur % 2
#         s.append(_char((cur + 1) // 2))
#     return ''.join(s)


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)


def __starting_point():
    main()
__starting_point()

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))


def __starting_point():
    main()

__starting_point()

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='')
    
    


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())
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='')



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()


# python template for atcoder1
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))))


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())




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())

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())

#!/usr/bin/env python
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([chr(ord('a') + _) for _ in 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
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
# input = io.StringIO(os.read(0, os.fstat(0).st_size).decode()).readline
kk=lambda:list(map(int,input().split()))
k2=lambda:[int(x)-1 for x in 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([chr(97+x) for x in [x for x in ls1]]))


"""tri=[False]
def knight(x0,y0,moves,a):
	nonlocal n,tri
	m=[x0,y0]
	#elif moves==0:
	elif m==a:
		tri[0]=True
	x1=x0+1
	y1=y0+1

	if x1<=n and moves>0 and not([x1,y0] in y):
		knight(x1,y0,moves-1,a)
	if y1<=n and moves>0 and not([x0,y1] in y):
		knight(x0,y1,moves-1,a)

y=[]	#list of obstacles
n=int(input())	#n*n
k=int(input())	#no of moves
o=int(input())	#obstacles
for i in range(o):
	y+=[list(map(int,input().split(" ")))]

p=int(input())	#no of values to check
for i in range(p):
	x=[]
	tri[0]=False
	c=list(map(int,input().split(" ")))
	knight(1,1,k,c)
	print(tri[0])

	"""
"""
no=input()
towords(no[:])


def assist1(no):
	no=int(no)

	if no==1:
		to_add='one'
	elif no==2:
		to_add='two'
	elif no==3:
		to_add='three'
	elif no==4:
		to_add='four'
	elif no==5:
		to_add='five'
	elif no==6:
		to_add='six'
	elif no==7:
		to_add='seven'
	elif no==8:
		to_add='eight'
	elif no==9:
		to_add='nine'
	else:
		to_add=''

def assist2(no):
	below_hundred=int(no)

	
	if below_hundred==10:
		to_add='ten'
	elif below_hundred==20:
		to_add='twenty'
	elif below_hundred==30:
		to_add='thirty'
	elif below_hundred==40:
		to_add='forty'
	elif below_hundred==50:
		to_add='fifty'
	elif below_hundred==60:
		to_add='sixty'
	elif below_hundred==70:
		to_add='seventy'
	elif below_hundred==80:
		to_add='eighty'
	elif below_hundred==90:
		to_add='ninety'
	elif below_hundred==11:
		to_add='eleven'
	elif below_hundred==12:
		to_add='twelve'
	elif below_hundred==13:
		to_add='thirteen'
	elif below_hundred==14:
		to_add='fourteen'
	elif below_hundred==15:
		to_add='felifteen'
	elif below_hundred==16:
		to_add='sixteen'
	elif below_hundred==17:
		to_add='seventeen'
	elif below_hundred==18:
		to_add='eightteen'
	elif below_hundred==19:
		to_add='nineteen'
	else:
		to_add=''

def towords(no):

	if 10<below_hundred<20 or below_hundred%10==0:
		assist1(no[:-2])
	
	else:
		=assist(no[-1])

	if int(no)>100:
"""

#str_num=[]
#n=int(input())
#arr=input()
#for i in arr:
#	str_num.append(int(i))
"""
def find_sub(stri):
	maxi=0
	if stri[0]=='S':
		stri=stri[stri.find('G'):]

	while True:
		if stri.find('G')==-1 :
			break

		elif stri.find('S')==-1 :
			if len(stri)>maxi:
				maxi=len(stri)
			break

		end_index=stri.find('S')
		stri=stri[end_index:]

		if end_index > maxi:
			maxi=end_index

		var=stri.find('G')
		if var!=-1:
			stri=stri[var:]

	return maxi

			

		

def main():
	n=int(input())
	trophies=input()

	if trophies.find('S')==-1:
		return n
	if trophies.find('G')==-1:
		return 0


	maxy=0
	for i in range(n):
		for j in range(i+1,n):
			if trophies[i]!=trophies[j]:			
				temp=find_sub(trophies[:i]+trophies[j]+trophies[i+1:j]+trophies[i]+trophies[j+1:])
				if temp> maxy:
					maxy=temp

	return maxy

#print(main())

for i in range(100000):
	print("a", end="")"""

"""
def hhh():
	n,m=map(int,input().split())
	done=[]
	count=0

	A=list(map(int,input().split(" ")))
	B=list(map(int,input().split(" ")))

	for i in range(m):
		done.append(A[0]+B[i])
		print(0,i)


	while True:
		for i in range(n):
			for j in range(m):
				if(A[i]+B[j] not in done):
					print(i,j)
					done.append(A[i]+B[j])
					count+=1
					if count==m+n-1:
						print(done)
						return

hhh()


def Tee(N,M):
	if M - N>0:
		temp=str(M - N)
	else:
		temp=str(N - M)
#	print(temp)
	if (int(temp)/2)%2!=0:
		print("Even")
	else:
		print("Odd")

	
for i in range(int(input())):
	N,M=map(str,input().split(" "))
	if int(N[-1])%2==0:
		N1=int(N[-1])+1
#		print(N,N[-1],N1)
	else:
		N1=int(N[-1])
#		print(N,N[-1],N1)	
	if int(M[-1])%2==0:
		M1=int(M[-1])-1
#		print(M,M[-1],M1)
	else:
		M1=int(M[-1])
	Tee(N1,M1)"""
"""	
from copy import deepcopy
def rec(current,final,time):
	if memoization[current[0]][current[1]]!=-1 and memoization[current[0]][current[1]]+matrix[current[0]][current[1]]>memoization[][]

matrix=[]
memoization=[]
R,C=map(int,input().split())


temp=[-1 for i in range(C)]

for i in range(R):
	matrix.append(list(map(int,input().split())))
	memoization.append[temp[:]]

D=int(input())
current=[0,0]
for i in range(D):
	x=int(input())
	y=int(input())
	rec(current,[x-1,y-1])


N,K,w=map(int,input().split())

Arr=list(map(int,input().split()))
finalScore=0
for i in range(K):
	
	sumAll=0
	startAll=0
	endAll=0
	start=0
	sumI=0

	for j in range(N):
		if(j<w):
			start=0
			sumI+=Arr[j]
		else:
			start=j-w+1
			sumI+=(Arr[j]-Arr[j-w])

		if(sumI>sumAll):
			sumAll=sumI
			startAll=start
			endAll=j

	for j in range(N-w,N):
		sumI-=Arr[j]
		start=j+1

		if(sumI>sumAll):
			sumAll=sumI
			startAll=start
			endAll=N-1
	print(startAll,endAll)
	for q in range(startAll,endAll+1):
		Arr[q]=0
	print(Arr)
	finalScore+=sumAll

print(finalScore)
class div(object):

	def __init__(self,no5,no2):
		self.no2 = no2
		self.no5 = no5

	def __add__(self,toadd):
		return(div(self.no5+toadd.no5,self.no2+toadd.no2))
	
a=[]
ans=[[]]
path=[[]]

def rec(divObj,i,j,N,pathi):
	zeros=min(divObj.no5,divObj.no2)

	if ans[i][j]!=-1 and zeros<ans[i][j]:
		ans[i][j]=zeros
		path[i][j]=pathi
	elif ans[i][j]==-1:
		ans[i][j]=zeros
		path[i][j]=pathi
	else:
		return

	if j+1<N:
		rec(divObj+a[i][j+1],i,j+1,N,pathi+"R")

	if i+1<N:
		rec(divObj+a[i+1][j],i+1,j,N,pathi+"D")

N=int(input())

for i in range(N):
	a.append(list(map(int,input().split())))

for i in range(N):
	for j in range(N):
		temp=a[i][j]

		a[i][j]=div(0,0)

		br1=temp

		while True:
			br1=br1/5
			if br1%1==0:
				a[i][j].no5+=1
			else:
				break

		br2=temp

		while True:
			br2=br2/2
			if br2%1==0:
				a[i][j].no2+=1
			else:
				break

ans = [[-1 for i in range(N)] for j in range(N)]
path = [["" for i in range(N)] for j in range(N)]

rec(a[0][0],0,0,N,"")

print(ans[N-1][N-1])
print(path[N-1][N-1])"""


dicti={}
for i in range(26):
	dicti[chr(97+i)]=i+1

#print(dicti)

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
	#print(i,divide,delta)

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="")

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)

#	✪ H4WK3yE乡
#	Mayank Chaudhary
#	ABES EC , Ghaziabad
# ///==========Libraries, Constants and Functions=============///
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):                                                             # <------  To calculate factorial of n under modulo m
    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):                                                          # < ------ To calculate nCr mod p value using Fermat Little under modulo m
    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):                                                          # <----- sieve of eratosthenes for prime no.
    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):                                             #  <----- calculate the no. of 1's in binary representation of number
    result=0
    while number:
        result=result+1
        number=number&(number-1)
    return result

def calculate_factors(n):                                #<---- most efficient method to calculate no. of factors of number             
    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):                                         #<------------ to find prime factors of a no.
    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):                                                      #<-----------check whether a no. is prime or not
    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):   # only odd numbers
        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()
# ///==========MAIN=============///
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='')


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)