s = input()
if s.isupper():
    print('A')
else:
    print('a')

N, K = map(int,input().split())
P = list(map(int,input().split()))
P.sort()
print (sum(P[:K]))

N = int(input())
ans = ''
while(N):
    N -= 1
    ans+=chr(ord('a')+N % 26)
    N //= 26
print (ans[::-1])

N = int(input())
A = list(map(int, input().split()))
d = dict()
for a in A:
    v = d.get(a, 0)
    d[a] = v+1
S = sum(A)
Q = int(input())
B = []
C = []
for q in range(Q):
    b, c = map(int,input().split())
    v = d.get(b, 0)
    S += v*(c-b)
    d[b] = 0
    d[c] = d.get(c,0) + v
    print (S)

from functools import reduce
N = input()
A = list(map(int,input().split()))
S = reduce(lambda x, y : x ^ y, A)
ans = [str(S^a) for a in A]
print (' '.join(ans))

import itertools
N, M = map(int, input().split())
P = list(map(int, input().split()))
A = []
B = []
C = []
for n in range(N-1):
    a,b,c = map(int, input().split())
    A.append(a)
    B.append(b)
    C.append(c)
imos = [0] * N
for m in range(M-1):
    if P[m] < P[m+1]:
        imos[P[m]-1] += 1
        imos[P[m+1]-1] -= 1
    else:
        imos[P[m]-1] -= 1
        imos[P[m+1]-1] += 1
csum = list(itertools.accumulate(imos))
ans = 0
for n in range(N-1):
    cnt = csum[n]
    ans += min(A[n]*cnt, B[n]*cnt+C[n])
print (ans)umulate(imos))
print (max(csum))

import itertools
def transpose(mat): # 二次元のリストを転置する関数
    return list(zip(*mat))
M, N  = map(int, input().split())
K = int(input())
A = []
for m in range(M):
    a = input()
    A.append(a)

J = [[0] * (N+1) for _ in range(M+1)]
O = [[0] * (N+1) for _ in range(M+1)]
I=  [[0] * (N+1) for _ in range(M+1)]

for m in range(M):
    for n in range(N):
        if A[m][n]=='J':
            J[m+1][n+1] = 1
        elif A[m][n] == 'O':
            O[m+1][n+1] = 1
        else:
            I[m+1][n+1] = 1
            

def calc_csum_mat(A):
    B = []
    for a in A:
        csum = list(itertools.accumulate(a))
        B.append(csum)
    B = transpose(B)

    csum_mat = []
    for a in B:
        csum = list(itertools.accumulate(a))
        csum_mat.append(csum)
    csum_mat = transpose(csum_mat)
    return csum_mat

J = calc_csum_mat(J)
O = calc_csum_mat(O)
I = calc_csum_mat(I)
query = []
def calc_csum(mat,a,b,c,d):
    a -= 1
    b -= 1
    return str(mat[c][d] - mat[c][b] - mat[a][d] + mat[a][b])
for k in range(K):
    query.append(list(map(int,input().split())))
for q in query:
    a,b,c,d = q
    print (calc_csum(J,a,b,c,d) + ' ' + calc_csum(O,a,b,c,d) + ' ' + calc_csum(I,a,b,c,d))

import math
a,b,c = map(int,input().split())
def func(t):
    return a * t + b * math.sin(c*t*math.pi)
l = 0
r = 400
for i in range(100):
    mid = (l + r) / 2
    if func(mid)>100:
        r = mid
    else:
        l = mid
print (mid,func(mid))

def solve():
    ans = []
    while(1):
        N = int(input())
        if N==0:
            break
        W = list(map(int,input().split()))
        dp = [[0]*N for _ in range(N)]
        for d in range(1,N):
            for i in range(N-d):
                j = i+d
                if d%2==1:
                    if dp[i+1][j-1]==d-1:
                        if abs(W[i] - W[j])<=1:
                            dp[i][j] = d+1 
                        else:
                            dp[i][j] = d-1
                    for k in range(i+1,j):
                        new = dp[i][k]+dp[k+1][j]
                        if new > dp[i][j]:
                            dp[i][j] = new
                else:
                    dp[i][j] = max(dp[i+1][j], dp[i][j-1])
        ans.append(dp[0][-1])
    for a in ans:
        print(a)
solve()

def solve():
    ans = []
    INF = 10**10
    while(1):
        N, M = map(int,input().split())
        if N==0:
            break
        C = [int(input()) for _ in range(M)]
        X = [int(input()) for _ in range(N)]
        dp1 = [INF]*256
        dp2 = [INF]*256
        dp1[128] = 0
        cost = []
        decoder = tuple(tuple(255 if i + c > 255 else 0 if i + c < 0 else i + c for c in C) for i in range(256))
        ls_square = tuple(tuple((x - t)**2 for x in range(256)) for t in range(256))
        for n in range(N):
            x = X[n]
            square = ls_square[x]
            for k in range(256):
                dpnk = dp1[k]
                for code in decoder[k]:
                    # #dp[n+1][d] = min(dp[n+1][d], dp[n][k] + (d-X[n])**2)
                    new = dpnk + square[code]
                    if new < dp2[code]:
                        dp2[code] = new  
            dp1 = dp2[:]
            dp2 = [INF]*256                      
        ans.append(min(dp1))
    for a in ans:
        print(a)
solve()

A = list(map(int,input().split()))
for i in range(5):
    if A[i] == 0:
        print(i+1)

x, y = map(int,input().split())
for a in range(x+1):
    b = x-a
    if 2*a+4*b==y:
        print ('Yes')
        exit()
print ('No')

X, N = map(int,input().split())
P = list(map(int,input().split()))
P.sort()
diff = 10**10
for p in range(102):
    if p in P:
        continue
    if abs(X-p) < diff:
        diff = abs(X-p)
        ans = p
print (ans)

from collections import Counter
import bisect
N = int(input())
A = list(map(int,input().split()))
cnt = Counter(A)
A.sort()
ans = 0
MX = 10**6
P = [0] * (MX+1)
for a in A:
    if P[a]==0:
        for i in range(MX+1):
            x = a*i
            if x > MX:
                break
            P[x] = 1
        if cnt[a]==1:
            ans+=1
print (ans)

from collections import deque
dxdy = ((-1,0), (1,0), (0,-1), (0,1)) # タプルやリストで持っておくと便利

H, W, K = map(int,input().split())
x1, y1, x2, y2 = map(int,input().split())
mp = [input() for _ in range(H)]
INF = 10**10
dist = [[INF]*W for _ in range(H)]
dist[x1-1][y1-1] = 0
q = deque()
q.append((x1-1,y1-1)) # スタート地点をenqueue
while(q):
    x, y = q.popleft()
    if x==x2-1 and y==y2-1:
        print (dist[x2-1][y2-1])
        exit()
    else:
        for dx, dy in  dxdy:
            for i in range(1,K+1):
                nx = x + dx*i
                ny = y + dy*i
                if not (0<=nx<H and 0<=ny<W) or mp[nx][ny]=='@':
                    break
                if dist[nx][ny] <= dist[x][y]:
                    break 
                if dist[nx][ny] == INF:
                    q.append((nx,ny))
                    dist[nx][ny] = dist[x][y] + 1
print(-1)