We have a string S consisting of uppercase English letters. Additionally, an integer N will be given.
Shift each character of S by N in alphabetical order (see below), and print the resulting string.
We assume that A follows Z. For example, shifting A by 2 results in C (A \to B \to C), and shifting Y by 3 results in B (Y \to Z \to A \to B).

-----Constraints-----
 - 0 \leq N \leq 26
 - 1 \leq |S| \leq 10^4
 - S consists of uppercase English letters.

-----Input-----
Input is given from Standard Input in the following format:
N
S

-----Output-----
Print the string resulting from shifting each character of S by N in alphabetical order.

-----Sample Input-----
2
ABCXYZ

-----Sample Output-----
CDEZAB

Note that A follows Z.

Difficulty: introductory

Starter code:

Solutions:
n = int(input())
s = list(input())
for a in range(len(s)):
    s[a] = chr(ord(s[a]) + n)
    if ord(s[a])>90:
        s[a] = chr(ord(s[a])-26)
c=s[0]
for b in range(len(s)-1):
    c = c + s[b+1]
print(c)

n = int(input())
s = list(input())
for i in range(len(s)):
  s[i] = chr((ord(s[i]) + n - ord('A')) % 26 + ord('A'))
print(''.join(s))

n = int(input())
s = list(input())
alp = list('ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ')

for i in range(len(s)):
    for j in range(26):
        if s[i] == alp[j]:
            s[i] = alp[j+n]
            break

print(''.join(s))

k=input()
l = input()

a1=[]

for i in l:
    n=(ord(i)-65+(int)(k))%26+65
    a1.append(chr(n))
a1=''.join(a1)
print(a1)

alphabet = ["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"]
N = int(input())
S = input()
ans = ""
for i in range(len(S)):
  x = alphabet.index(S[i])
  if x + N >= 26:
    y = x + N -26
  else:
    y = x + N
  ans += alphabet[y]
print(ans)

n = int(input())
s = list(str(input()))
a = ''
for i in s:
    b = (ord(i) + n - 65) % 26
    a += chr(b + 65)
print(a)

N = int(input())
S = input()

new_s = []
for c in S:
    new_s.append(chr((ord(c) - ord("A") + N) % 26 + ord("A")))

print("".join(new_s))

N=int(input())
S=input()
ans=[]

for i in range(len(S)):
	temp=ord(S[i])
	if temp+N>90:
		ans.append(chr(temp+N-26))
	
	else:
		ans.append(chr(temp+N))

print(("".join(ans)))


n=int(input())
S=input()
ans = ""
for s in S:
  if (ord(s)+n) > 90:
    ans += chr(64+((ord(s)+n)%90))
  else:
    ans += chr(ord(s)+n)
print(ans)

al = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'
N = int(input())
S = list(input())

for i in range(len(S)):
    S[i] = al[al.index(S[i]) + N]

print(''.join(S))

n = int(input())
s = input()
ans = ''
for i in range(len(s)):
    if ord(s[i])+n>90:
        ans  += chr(ord(s[i])+n-26)
    else:
        ans  += chr(ord(s[i])+n)
print(ans)

n = int(input())
s = list(input())
 
abc = list('ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
for i in range(len(s)):
    for j in range(len(abc)):
        if s[i] == abc[j]:
            s[i] = abc[j+n]
            break
 
print(''.join(s))

n = int(input())
s = list(input())
ans=[]
for e in s:
    od=ord(e)+n
    if od > 90:
        od = 64+od-90
    ans.append(chr(od))
print("".join(ans))

from string import ascii_uppercase

n = int(input())
s = input()
uu = ascii_uppercase*3

d = {}
for i in range(27):
    d[uu[i]] = uu[i+n]

ans = ""
for c in s:
    ans += d[c]

print(ans)

n=int(input())
s=input()
t=str()
for i in range(len(s)):
    if ord(s[i])+n<=90:
        t+=chr(ord(s[i])+n)
    else :
        t+=chr(ord(s[i])+n-26)
print(t)


n = int(input())
s = list(input())
ans = ""
for i in range(len(s)):
    s[i] = ord(s[i]) + n
    if s[i] >=91:
        s[i] -= 26
    ans += chr(s[i])
print(ans)
    



N = int(input())
S = list(input())

a = list('ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ')
ans = ''
for i in range(len(S)):
  ans += a[a.index(S[i]) + N]
  
print(ans)

N = int(input())
S = input()

ans = ''
Z_s = 'Z'
for i in range(len(S)):
    ord_s = ord(S[i]) + N
    if ord_s > ord(Z_s):
        ord_s -= ord('Z') - ord('A') + 1
    ans += chr(ord_s)
print(ans)

from string import ascii_uppercase as au

N = int(input())
S = input()
ans = ''
for s in S:
	idx = (au.index(s) + N) % len(au)
	ans += au[idx]
print(ans)

# 問題：https://atcoder.jp/contests/abc146/tasks/abc146_b

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

res = ''

for letter in s:
    res += chr(ord('A') + (ord(letter)-ord('A')+n) % 26)

print(res)


def rot_n():
    n = int(input())
    s = input()

    answer = ''
    for letter in s:
        answer += chr(ord('A') + (ord(letter)-ord('A')+n) % 26)

    print(answer)


def __starting_point():
    rot_n()
__starting_point()

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

result = ""

# Aの文字コードに、各文字の文字コードをAの文字コ2ードで企画化？した文字コードにnを足して26で割った余りを足して、文字に戻す
for c in s:
  result += chr(ord("A") + (ord(c) - ord("A") + n) % 26)

print(result)

def main():
   N = int(input())
   S = input()
   S = list(S)
   size = len(S)
   for i in range(size):
      num = ord(S[i]) + N
      if(num > 90):
         num -= 26
      S[i] = chr(num)
   for i,item in enumerate(S):
      print(item,end="")
   print("")
def __starting_point():
    main()


__starting_point()

N = int(input())
S = input()

lst = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
dct1 = {}
dct2 = {}
ans = []
for i, j in enumerate(lst, 1):
    dct1[j] = i
    dct2[i] = j
for s in list(S):
    n = dct1[s] + N
    if n >=27:
        n -= 26
    m = dct2[n]
    ans.append(m)
print(''.join(ans))

N = int(input())
S = list(input())
alp = [chr(i) for i in range(65, 65+26)]*2
for j in S:
    num = alp.index(j)
    print(alp[num+N],end="")

n = int(input())
s = input()
alp = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ"

for i in range(len(s)):
    print(alp[alp.index(s[i]) + n],end="")
print()

import string

N = int(input())
S = input()

# string.ascii_uppercase を覚えよう
a = string.ascii_uppercase
# a = ABCDEFGHIJKLMNOPQRSTUVWXYZ

ans = ''
for s in S:
  num = (a.index(s) + N) % len(a)
  ans += a[num]
  
print(ans)  



#!/usr/bin/env python3
n=int(input())
s=input()
ans=""
for i in s:
    ans += chr(ord('A') + (ord(i)-ord('A')+n) % 26)
print(ans)

a=int(input())
b=input()
c=[]
d=[]
e=""
for i in range(len(b)):
  c.append(ord(b[i]))
for i in range(len(b)):
  d.append((int(c[i])+a-65)%26+65)
for i in range(len(b)):
  e=e+chr(d[i])
print(e)

import string
n = int(input())
s = input()

l = string.ascii_uppercase
ans = [l[(l.index(i) + n ) % len(l)] for i in s]
print(''.join(ans))

N = int(input())
S = input()

alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

ans = ''
for word in S:
    index = alphabet.index(word)

    new_index = (index + N) % 26
    ans = ans + alphabet[new_index]

print(ans)


import string

N = int(input())
S = input()

a = string.ascii_uppercase
# a = ABCDEFGHIJKLMNOPQRSTUVWXYZ

ans = ''
for s in S:
  ans += a[(a.index(s) + N) % len(a)]
  
print(ans)

N = int(input())
S = input()
ans = ''
for letter in S:
  ans += chr((ord(letter)+N-ord('A'))%26 + ord('A'))
print(ans)

W = {"A":1, "B":2, "C":3, "D":4,"E":5,"F":6,"G":7,"H":8,"I":9,"J":10,"K":11,"L":12,"M":13,"N":14,"O":15,"P":16,"Q":17,"R":18,"S":19,"T":20,"U":21,"V":22,"W":23,"X":24,"Y":25,"Z":0}
n=int(input())
A=input()
ans=""

for i in A:
    for j,k in W.items():
        #print(k,W[i],n,W[i]+n,(W[i]+n)%26)
        if k==((W[i]+n)%26):
            ans+=j
print(ans)

n = int(input())
s = list(input())
ans = ''

for i in s:
    ascii_code = (ord(i) + n)
    if ascii_code >= 91:
        ascii_code -= 26

    ans += chr(ascii_code)

print(ans)


num = int(input())

node = input()
table = list(node)


for i in table:
    aaa = ord('A') + ((ord(i) - (ord('A')) + num) % 26)
    print(chr(aaa), end='')
    

N = int(input())
S = input()
answer = []
for s in S:
    answer.append(chr(((ord(s) + N - 65) % 26) + 65))
print(''.join(answer))

A = int(input())
a = list(input())
s = ''
for i in a:
  
  k = (ord(i)+A-65)%26
  s += chr(k+65)
  #print(i,k,chr(k))

print(s)

def rot_n(s, n):
  answer = ''
  for letter in s:
      answer += chr(ord('A') + (ord(letter)-ord('A')+n) % 26)

  return answer

### https://qiita.com/TodayInsane/items/94f495db5ba143a8d3e0

N = int(input())
S = str(input())

print(rot_n(S, N))

n = int(input())
s = input()
al = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ans = ""

for i in s:
    ind = al.index(i) + n
    ans += al[ind % 26]

print(ans)


n=int(input())
s=list(str(input()))
for i in range(len(s)):
  ns=ord(s[i])-64
  print(chr((ns+n-1)%26+65),end='')

n=int(input())
s=input()
ans=[]
for i in range(len(s)):
    num=ord(s[i])+n
    if num>90:
        num-=26
    ans.append(chr(num))
ans="".join(ans)
print(ans)

n = int(input())
s = list(map(str,input()))
ans = [chr((ord(s[i])-ord("A")+n)%26+ord("A")) for i in range(len(s))]
print("".join(ans))

N = int(input())
S = list(input())
L = [chr(x) for i in range(2) for x in range(65, 65 + 26)]

for s in S:
    ind = L.index(s)
    print(L[ind + N], end="")

print("")



import numpy as np

# 文字列Sのシフト数Nを取得
N = int(input())

# 文字列Sを取得
S = input()

# 文字列Sの各文字をasciiに変換
ascii_S = np.array(list(map(ord, S))) - 65

# asciiの数値をN分シフトさせる
shift_ascii_S = list(map(lambda x: 65 + np.mod(x + N, 26), ascii_S))

# ascii変換をそれぞれ文字に逆変換して結合
shift_S = ''.join(list(map(chr, shift_ascii_S)))

# 結果出力
print(shift_S)

N = int(input())
S = list(input())
T = [ord(i) for i in S]
for i in range(len(S)):
    T[i] += N
    if(T[i] > 90):
        T[i] -= 26
U = [chr(i) for i in T]
print("".join(U))

n=int(input());print(*[chr(ord(i)+n+[0,-26][ord(i)+n>90]) for i in input()],sep='')

abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

N = int(input())
S = input()

ans = []
for c in S:
    print(abc[(abc.index(c) + N) % len(abc)], end = "")

# 入力
N =int(input())
S = list(input())

for i in range(len(S)):
    uni = ord(S[i]) + N
    if uni > 90: 
        uni = uni - 26
    S[i] = chr(uni)
print(''.join(S))

import string
abc =list(string.ascii_uppercase)

n = int(input())
s = list(input())

for i in range(len(s)):
  x = abc.index(s[i])
  s[i] = abc[(x+n) % 26]
print((''.join(s)))


from functools import reduce

N = int(input())
S = input()

ans = [chr(ord("A") + (ord(s) + N - ord("A"))%26) for s in S]

ans = reduce(lambda x, y: x + y, ans)

print(ans)

n = int(input())
s = input()
ans = ''
for letter in s:
    ans += chr(ord('A') +(ord(letter) - ord('A') + n) % 26)
print(ans)

N = int(input())
S = input()
s = []
for i in range(len(S)):
  s.append(chr(((ord(S[i])-65)+N)%26+65))
print("".join(s))

ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq

n = ni()
s = input()
def wid(w):
    return ord(w)-ord("A")
def ws(wid):
    return chr(wid+ord("A"))
ans = ""
for i in range(len(s)):
    id = (wid(s[i])+n)%26
    ans+=ws(id)
print(ans)


#!/usr/bin/env python3


def solve(N: int, S: str):
    answer = ""
    for s in S:
        answer += chr(65 + (ord(s) - 65 + N) % 26)
    return answer


def main():
    N = int(input())
    S = input().strip()
    answer = solve(N, S)
    print(answer)


def __starting_point():
    main()

__starting_point()

ALP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'

n = int(input())
S = input()
for s in S:
    print(ALP[ALP.index(s)+n],end='')

def resolve():
    n = int(input())
    s = input()
    ans = ''
    for i in s:
        ans += chr(ord('A')+(ord(i)-ord('A')+n)%26)
    print(ans)
resolve()

a = [chr(i) for i in range(65, 65+26)]
n = int(input())
s = input()
ans = ''
for i in s:
    ans += (a[(a.index(i)+n)%26])
print(ans)

n = int(input())
s = input()
lst = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')

ans = ''
for i in range(len(s)):
  ans += lst[(lst.index(s[i]) + n) % 26]
  
print(ans)

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

abc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' * 2
ans = ''
for i in s:
    ans += abc[abc.index(i)+n]
print(ans)

n=int(input())
s=input()
ans=''
for i in range(len(s)):
    ans+=chr((ord(s[i])-ord('A')+n)%26+ord('A'))
print(ans)

n=int(input())
s=list(input())
ans=[]
for i in range(len(s)):
  a=int(((ord(s[i])+n)%65)%26)
  ans.append(chr(a+65))

print((''.join(ans)))


N=int(input())
S=input()
answer=""

for x in S:
  x=chr(ord(x)+N)
  if ord(x)>ord("Z"):
    x=chr(ord("A")+(ord(x)-ord("Z")-1))
  answer+=x
print(answer)

N = int(input())
S = input()
def change():
    s=[]
    for i in range(len(S)):
        m = ((ord(S[i])-ord("A")+N) % 26)
        s.append(chr(m+ord("A")))
    return "".join(s)
print(change())

def f(s, n):
    ans = ''
    for c in s:
        ans += chr(ord('A') + (ord(c)-ord('A')+n) % 26)
    return ans

N = int(input())
S = input()
print(f(S, N))

import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 1
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"
AL = al.upper()


n = k()
S = list(v())

for i in range(len(S)):
    a = AL.index(S[i])
    ans = a+n
    if ans >= 26:
        ans = (a+n)-26
    S[i] = AL[ans]

print("".join(S))

n = int(input())
s = list(input())
li = ['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','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']
li1 = []
for i in s:
    li1.append(li[li.index(i)+n])

print((''.join(li1)))


import sys

sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inl = lambda: [int(x) for x in sys.stdin.readline().split()]
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))


def solve():
    n = ini()
    s = ins()
    ans = []
    for c in s:
        x = chr((ord(c) - ord("A") + n) % 26 + ord("A"))
        ans.append(x)
    return "".join(ans)


print(solve())


import string
N = int(input())
S = input()
ascii_uppercase = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
for s in S:
    s_index = ascii_uppercase.index(s)
    ans_index = (s_index + N) % len(ascii_uppercase)
    print(ascii_uppercase[ans_index], end="")


import numpy as np

# 文字列Sのシフト数Nを取得
N = int(input())

# 文字列Sを取得
S = input()

# Aのascii
base_ascii= 65

# アルファベットリスト
als = [chr(a) for a in range(65, 90 + 1)]

# 文字列Sの各文字をasciiに変換
ascii_S = np.array(list(map(ord, S))) - base_ascii

print(''.join([als[np.mod(s + N, len(als))] for s in ascii_S]))

n = int(input())
s = list(input())
for i in range(len(s)):
  s[i] = chr((ord(s[i])-65+n) % 26 + 65)
print("".join(s))

n = int(input())
s = list(input())
ans = ""
for char in s:
  ans += chr(((ord(char)-65 + n) % 26) + 65)

print(ans)

N = int(input())
S = input()
ls = ['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']
lsS = list(S)
lsans = []
for i in range(len(S)):
    lsans.append(ls[(ls.index(lsS[i])+N) % 26])
print(''.join(lsans))

N = int(input())
S = input()
c = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')

ans = ''
for i in range(len(S)):
    ans += c[(c.index(S[i]) + N) % 26]

print(ans)
return


n = int(input())
s = input()
ss = [chr(65+(ord(i)-65+n)%26) for i in s ]
print(*ss,sep="")


num_a = ord("A")
num_z = ord("Z")

N = int(input())
S = input()
ans = ""
for char in S:
  tmp = N + ord(char)
  if tmp > num_z:
    ans += chr(tmp-26)
  else:
    ans += chr(tmp)
print(ans)

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

mozi = ["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"]

for x in s:
  number = mozi.index(x) + n
  if number > 25:
    number = number - 26
  print(mozi[number], end="")
  

N=int(input());print("".join(map(lambda x:chr((ord(x)-65+N)%26+65),input())))

n = int(input())
s =input()
ans = ''
for i in s:
    ans += chr((ord(i) + n - ord('A')) % 26 + ord('A'))
print(ans)


N = int(input())
S = str(input())
ans = ""
for i in range(len(S)):
    if ord(S[i]) + N > 90:
        c = ord(S[i]) + N -26
    else:
        c = ord(S[i]) + N
    ans += chr(c)
print(ans)

def answer(n: int, s: str) -> str:
    result = []
    A = ord('A')
    for i in s:
        result.append(chr(A + (ord(i) - A + n) % 26))

    return ''.join(result)


def main():
    n = int(input())
    s = input()
    print((answer(n, s)))


def __starting_point():
    main()

__starting_point()

#!/usr/bin/env python3
def main():
    N = int(input())
    S = input()

    res = ord('A')
    ans = ''
    for s in S:
        ans += chr(res + (ord(s) - res + N) % 26)
    print(ans)


def __starting_point():
    main()

__starting_point()

n = int(input())
s = input()
for i in s:
    c = ord(i)+n
    if c >= 91:
        c = c-26
    print(chr(c), end='')
print()

N = int(input())
S = list(input())

print("".join(chr(65+(ord(s)-65+N)%26) for s in S))

n = int(input())
list_s = list(input())
for i in range(0, len(list_s)):
    tmp = ord(list_s[i]) + n
    if tmp > ord("Z"):
        tmp -= 26
    list_s[i] = chr(tmp)
print("".join(list_s))

N = int(input())
S = input()
ss = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ"
ans = ""
for s in S:
    ans += ss[ss.index(s)+N]
print(ans)

l="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
L=[]
n=int(input())
s=input()
for i in range(len(s)):
    L.append(l[(l.index(s[i])+n)%26])
    
L=''.join(L)
print(L)

# 入力を受け取る
N=int(input())
S=input()

# 文字cをN文字ずらすことを考える（Aを基準とした26進数を考える）

# Aの文字コードを取得する
code_A = ord('A')

results = ''

for c in S:
    # 文字cをn文字シフトした文字コードを求める
    # 文字cをn文字シフトした文字コードから(Aで規格化するために)Aの文字コードを減算して26で割った余りを考える
    after_n = (ord(c)+N-code_A)%26
    
    # 結果を文字リストに追加していく
    results += chr(code_A+after_n)

# 出力する
print(results)

n=int(input())
s=input()
a="abcdefghijklmnopqrstuvwxyz".upper()*2

for i in s:
    b=a[a.index(i)+n]
    print(b,end="")

N = int(input())
S = input()

abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
Sn = ""
for i in range(len(S)):
  Sn += abc[(abc.find(S[i])+N) % 26]
print(Sn)

N = int(input())
S = input()
ans = ""

for i in range(len(S)):
    ans += chr(int(ord("A"))+(int(ord(S[i])+N)-int(ord("A")))%26)

print(ans)

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

for i in s:
  print(chr((ord(i) - 65 + n) % 26 + 65), end="")

n=int(input())
s=input()
print(*[chr(65+(ord(i)+n-65)%26) for i in s],sep="")

n=int(input())
s=input()
alp="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
new_s=""
for i in range(len(s)):
  for j in range(26):
    if s[i]==alp[j]:
      if j+n>=26:
        new_s+=alp[j+n-26]
      else:
        new_s+=alp[j+n]
print(new_s)

N = int(input())
S = list(input())

a = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
ans = ''
for s in S:
  num = a.index(s) + N
  if num <= 25: ans += a[num]
  else: ans += a[num-26]
  
print(ans)

#!/usr/bin/env python3
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
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(10000)
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 sum_of_arithmetic_progression(s, d, n):
    return n * (2 * s + (n - 1) * d) // 2


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 solve():
    N = int(input())
    S = input()
    ans = ""
    for c in S:
        v = ord(c) - ord("A")
        ans += chr(ord("A") + ((v + N) % 26))
    print(ans)


def main():
    solve()


def __starting_point():
    main()

__starting_point()

N = int(input())
S = input()
ss = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
ans = [ss[(ss.index(s)+N)%26] for s in S]
print(("".join(ans)))


N=int(input())
S=input()
T="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for c in S:
    print(T[(T.index(c)+N)%26],end='')
print()


A=["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"]
n=int(input())
s=str(input())
t=""
for i in range(len(s)):
  for j in range(26):
    if s[i]==A[j]:
      if j+n<=25:
        t+=A[j+n]
        break
      else:
        t+=A[j+n-26]
        break

print(t)