Problem:
 Score : 100 points    Problem Statement An uppercase or lowercase English letter \alpha will be given as input.
If \alpha is uppercase, print A ; if it is lowercase, print a .      Constraints  \alpha is an uppercase ( A - Z ) or lowercase ( a - z ) English letter.         Input Input is given from Standard Input in the following format:  α       Output If \alpha is uppercase, print A ; if it is lowercase, print a .        Sample Input 1 B      Sample Output 1 A  B is uppercase, so we should print A .       Sample Input 2 a      Sample Output 2 a  a is lowercase, so we should print a .

Solution (Python):
N = input()
if N.islower():
  print("a")
else:
  print("A")

Solution (Python):
a=input()
if a.lower()==a:
    print("a")
else:
    print("A")

Solution (Python):
s = str(input())

if s.isupper():
  print("A")
else:
  print("a")

Solution (Python):
s = input()

if s == s.upper():
  print("A")
else:
  print("a")

Solution (Python):
A = input()

if A == A.upper():
    print('A')
else:
    print('a')

Solution (Python):
import sys
import math
import itertools
n=input()

if(n==n.lower()):
    print('a')
else:
    print('A')

Solution (Python):
s = str(input())
if ord("a") <= ord(s) <= ord("z"):
  print("a")
else:
  print("A")

Solution (Python):
x = input()
if x.isupper():
    print("A")
else:
    print("a")

Solution (Python):
alpha = input()
if alpha.islower():
    print('a')
else:
    print('A')

Solution (Python):
x=input()
if(x.isupper()):
    print("A")
else:
    print("a")

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

Solution (Python):

import heapq
from collections import defaultdict, deque
from math import ceil, factorial, gcd
from itertools import accumulate, permutations
import sys
sys.setrecursionlimit(10 ** 7)
import bisect


INF = float("inf")
MOD = 10 ** 9 + 7


import string

a = input().strip()

if a in string.ascii_uppercase:
    print('A')
else:
    print('a')

Solution (Python):
import sys

stdin = sys.stdin


def ni(): return int(ns())


def na(): return list(map(int, stdin.readline().split()))


def naa(N): return [na() for _ in range(N)]


def ns(): return stdin.readline().rstrip()  


a = ns()

if a >= "A" and a <= "Z":
    print("A")
else:
    print("a")

Solution (Python):
import sys

readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prl = lambda x: print(*x ,sep='\n')


a = ns()
b = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
if a in b:
    print('A')
else:
    print('a')

Solution (Python):
print('A' if input().isupper() else 'a')

Solution (Python):
a = input()

if a.isupper():
  print("A")
else:
  print("a")

Solution (Python):
a = input()

if 'A' <= a <= 'Z':
    print('A')
else:
    print('a')

Solution (Python):
import sys
import collections
INF = 10**18
ans = 0
import math

if __name__ == "__main__":
    a = input()
    if a.islower():
        print("a")
    else:
        print("A")

Solution (Python):
def main():
    s = input()
    S = s.upper()
    if s == S:
        print("A")
    else:
        print("a")    
    
if __name__ == '__main__':
    main()

Solution (Python):
s = input()
if 65<=ord(s)<=90:
  print('A')
else:
  print('a')

Solution (Python):
if input().islower():
  print('a')
else:
  print('A')

Solution (Python):
s = input()
if s.isupper():
    print("A")
else:
    print("a")

Solution (Python):
s = input()

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

Solution (Python):
a = input()

print('Aa'[a == a.lower()])

Solution (Python):

alpha = input()

if alpha.islower():
    print("a")
else:
    print("A")

Solution (Python):
def main():
    
    
    s = input()
    if(s>"Z"):
        res = "a"
    else:
        res = "A"
    print(res)

if __name__ == '__main__':
    main()

Solution (Python):
s=input()
if s.lower()==s:
  print('a')
else:
  print('A')

Solution (Python):
S = input()

if S.isupper():
    print('A')
else:
    print('a')

Solution (Python):
s = input()
if s.upper() == s:
    print('A')
else:
    print('a')

Solution (Python):
from math import *

a=input()
if ord(a)<97:
	print("A")
else:
	print("a")

Solution (Python):
a=input()
if ord('a')<=ord(a)<=ord('z'):
    print('a')
else:
    print('A')

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

Solution (Python):
a = input()
alphabet = [chr(i) for i in range(97, 97+26)]
if a in alphabet:
    print('a')
else:
    print('A')

Solution (Python):
a = input()

if str.isupper(a) == True:
    print("A")
else:
    print("a")

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

Solution (Python):
def solve():
    a = input()
    if a.isupper():
        print("A")
    else:
        print("a")
    return 0

if __name__ == "__main__":
    solve()

Solution (Python):
alp="abcdefghijklmnopqrstuvwxyz"
if input() in alp:
    print("a")
else:
    print("A")

Solution (Python):

alp = [chr(i) for i in range(97, 97+26)]
a = input()
if a in alp:
    print('a')
else:
    print('A')

Solution (Python):
s = input().strip()

if s.lower()==s:
    print("a")
else:
    print("A")

Solution (Python):
a = str(input())

if a.upper() == a:
    res = "A"
else:
    res = "a"

print(res)

Solution (Python):
a = input()

if a.islower():
    print('a')
else:
    print('A')

Solution (Python):
def main():
    a = input()
    if a.isupper():
        print("A")
    else:
        print("a")
if __name__ == '__main__':
    main()

Solution (Python):
n = input()
if n.isupper():
  print("A")
else:
  print("a")

Solution (Python):
if input().islower():
    print('a')
else:
    print('A')

Solution (Python):
a = str(input())
if a.isupper():
    print('A')
else:
    print('a')

Solution (Python):


import sys
input=sys.stdin.readline

def main():
    c=input()
    if c.isupper():
        print("A")
    else:
        print("a")
    
    
    
if __name__=="__main__":
    main()

Solution (Python):
def main():
    a = input()
    if a.isupper():
        print('A')
    else:
        print('a')

if __name__ == '__main__':
    main()

Solution (Python):
if __name__ == '__main__':
    letter = input()
    if letter.isupper():
        print('A')
    else:
        print('a')

Solution (Python):
c = input()

if ord('a') <= ord(c) <= ord('z'):
    print('a')
else:
    print('A')

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do(): 
    a=STR()
    if a==a.upper():
        print('A')
    else:
        print('a')
if __name__ == '__main__':
    do()

Solution (Python):
alpha = input().strip()

if alpha.islower():
  print("a")
else:
  print("A")

Solution (Python):
s = input()
if(s.upper() == s):
  print('A')
else:
  print('a')

Solution (Python):


N = input()



if N.islower():
    print("a")
else:
    print("A")

Solution (Python):
a = input()
if a.islower():
  print("a")
else:
  print("A")

Solution (Python):
l = 'ABDEFGHIJKLMNOPQRSTUVWXYZ'
if input() in l:
    print('A')
else:
    print('a')

Solution (Python):
a= input()

if a in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
    print('A')
else:
    print('a')

Solution (Python):
s = input()
if s.upper() == s:
  print('A')
else:
  print('a')

Solution (Python):
S = input()

Alp = [chr(i) for i in range(97, 97+26)]
print("a" if S in Alp else "A")

Solution (Python):
import sys
from collections import defaultdict, Counter, namedtuple, deque
import itertools
import functools
import bisect
import heapq
import math


MOD = 10 ** 9 + 7



s = input()
sl = s.lower()
if s == sl:
    print("a")
else:
    print("A")

Solution (Python):
A = input()

if A.isupper():
    print('A')
else:
    print('a')

Solution (Python):
def main():
    a = input()
    if a.isupper():
        print('A')
    else:
        print('a')



if __name__ == "__main__":
    main()

Solution (Python):
def main():
    s = input()
    if s.islower():
        print('a')
    else:
        print('A')


if __name__ == "__main__":
    main()

Solution (Python):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue


Mod = 1000000007
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1] 
for i in range(2, 10**5 + 1):
    fact.append((fact[-1] * i) % Mod)
    inv.append((-inv[Mod % i] * (Mod // i)) % Mod)
    factinv.append((factinv[-1] * inv[-1]) % Mod)
    
def cmb(n, r, p):
    if (r < 0) or (n < r):
        return 0
    r = min(r, n - r)
    return fact[n] * factinv[r] * factinv[n - r] % p
    
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[y] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

def main():  
    s = input()
    print("A" if s.lower() != s else "a")
if __name__ == "__main__":
    main()

Solution (Python):

import sys
import math
import itertools
import collections

a = input()
if a.upper() == a:
    print("A")
else:
    print("a")

Solution (Python):
a=input()
print("a" if a==a.lower() else "A")

Solution (Python):
s=input()

if s.islower():
    print('a')
else:
    print('A')

Solution (Python):
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
from decimal import Decimal
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


def dijkstra_heap(s, edge, n):
    
    d = [10**20] * n
    used = [True] * n 
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr


def lcm(x, y):
    return (x * y) // gcd(x, y)


def lcm_list(numbers):
    return reduce(lcm, numbers, 1)


def gcd_list(numbers):
    return reduce(gcd, numbers)


def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True



def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P


def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret



a = input()
if a in "abcdefghijklmnopqrstuvwxyz":
    print("a")
else:
    print("A")

Solution (Python):
a=input()
alp='abcdefghijklmnopqrstuvwxyz'
alps=set()
for i in alp:
  alps.add(i)
  
if a in alps:
  print('a')
else:
  print('A')

Solution (Python):
alp = input()
if alp.upper() == alp:
    print('A')
else:
    print('a')

Solution (Python):
cap = input()

if cap == str.upper(cap):
    print("A")
else:
    print("a")

Solution (Python):
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")



from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush

def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')





def main():
    c = input()
    if c.isupper():
        print('A')
    else:
        print('a')


if __name__ == "__main__":
    main()

Solution (Python):
import sys

sys.setrecursionlimit(10**6)
input = sys.stdin.readline


sletter = ['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']
bletter = ['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']

def main():
    s = input()[:-1]
    if s in sletter:
        print('a')
    else:
        print('A')


if __name__ == "__main__":
    main()

Solution (Python):
print('a' if input().islower() else 'A')

Solution (Python):
s = input().strip()
print("a" if s == s.lower() else "A")

Solution (Python):
import sys
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(rs())
def rs_(): return [_ for _ in rs().split()]
def ri_(): return [int(_) for _ in rs().split()]

a = rs()
if a in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
    print('A')
else:
    print('a')

Solution (Python):
a=input()
if a==a.lower():
    print("a")
else:
    print("A")

Solution (Python):
S = input()
if S in 'abcdefghijklmnopqrstuvwxyz':
    print('a')
else:
    print('A')

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

Solution (Python):

s = input()

if s.islower():
    print("a")
else:
    print("A")

Solution (Python):
a = input()

if a == str.upper(a):
    print("A")
else:
    print("a")

Solution (Python):
l = ["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 = input("")
if n in l:
    print("A")
else:
    print("a")

Solution (Python):
A=input()


if ord(A)<=ord("Z"):
  print("A")
else:
  print("a")

Solution (Python):
a = str(input())
if a == str.upper(a):
  print('A')
else:
  print('a')

Solution (Python):




def main():
    
    x = input()
    if x.isupper():
        print('A')
    else:
        print('a')
    pass

if __name__ == '__main__':
    main()

Solution (Python):
def resolve():
    A = input()
    if A in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
        print("A")
    else:
        print("a")


resolve()

Solution (Python):
a = input()

if (a.lower() == a) :
    print("a")
else :
    print("A")

Solution (Python):
alpha = input().strip()

if alpha.lower() == alpha:
	print('a')
else:
	print('A')

Solution (Python):
a=input()

b=a.upper()

if a==b:
    print('A')
else:
    print('a')

Solution (Python):

import sys, re
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log, floor
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

t = input()

if(t.isupper()):
    print('A')
else:
    print('a')

Solution (Python):
s=str(input())

if s.isupper():
  print("A")
else:
  print("a")

Solution (Python):
a = str(input())
if a.upper() == a:
    print('A')
else:
    print('a')

Solution (Python):
from sys import stdin, stdout
import heapq
import cProfile
from collections import Counter, defaultdict, deque
from functools import reduce
import math


def get_int():
    return int(stdin.readline().strip())


def get_tuple():
    return map(int, stdin.readline().split())


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


def solve():
    return

def main():
    st = input()
    if st.islower():
        print("a")
    else:
        print("A")


TestCases = False

if TestCases:
    for i in range(get_int()):
        main()
else:
    main()

Solution (Python):
"""
~~ Author : Bhaskar
~~ Dated : 10~06~2020
"""

import sys
from bisect import *
from math import floor,sqrt,ceil,factorial as F,gcd,pi
from itertools import chain,combinations,permutations,accumulate
from collections import Counter,defaultdict,OrderedDict,deque
from array import array
INT_MAX = sys.maxsize
INT_MIN = -(sys.maxsize)-1
mod = 1000000007
ch = "abcdefghijklmnopqrstuvwxyz"
lcm = lambda a,b : (a*b)//gcd(a,b)
setbit = lambda x : bin(x)[2:].count("1")
input = lambda : sys.stdin.readline()

def solve():
    s = sys.stdin.readline().replace("\n","")
    if s.isupper():
        print("A")
    else:
        print("a")


if __name__ == "__main__":
    try:
        sys.stdin = open('input.txt','r')
        sys.stdout = open('output.txt','w')
    except:
       pass
    solve()

Solution (Python):
a = input()
if a.isupper():
    print("A")
else:
    print("a")

Solution (Python):
S=lambda:input()
I=lambda:int(input())
L=lambda:list(map(int,input().split()))
LS=lambda:list(map(str,input().split()))

a=S()
print('A' if a.isupper() else 'a')

Solution (Python):
s = input()

if ord(s) >= 97:
    print("a")
else:
    print("A")

Solution (Python):
const=list('QWERTYUIOPASDFGHJKLZXCVBNM')
a=input()
if a in const:
  print('A')
else:
  print('a')

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

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

Solution (Python):


a = input()

if(a.isupper()):
    print("A")
else:
    print("a")

Solution (Python):
a = input()

if a.isupper():
    print('A')
else:
    print('a')

Solution (Python):
a = input()
if ord('a') <= ord(a) <= ord('z'):
    print('a')
else:
    print('A')

Solution (Python):
a = input()
if ord('a') <= ord(a) <= ord('z'):
    print('a')
else:
    print('A')

Solution (Python):
al = [chr(ord('a') + i) for i in range(26)]
AL = [chr(ord('A') + i) for i in range(26)]
s = input()
if s in al:
    print("a")
else:
    print("A")

Solution (Python):
a = input()

if a.upper() == a:
    print('A')
else:
    print('a')

Solution (Python):
def main():
    c = input()
    if c.islower():
        print('a')
    else:
        print('A')

main()

Solution (Python):
def main():
    s = input()
    if s == s.upper():
        print("A")
    else:
        print("a")
main()

Solution (Python):
a=input()
if a.isupper():
    print("A")
else:
    print("a")

Solution (Python):
s = input()
if 65 <= ord(s) <= 90:
    print("A")
else:
    print("a")

Solution (Python):
a = input()

if a.islower():
    print("a")
else:
    print("A")

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    a = input().rstrip()
    if a.isupper():
        print("A")
    else:
        print("a")

if __name__ == '__main__':
    main()

Solution (Python):
import sys
input = sys.stdin.readline

a = input()

if a.isupper():
    print("A")
else:
    print("a")

Solution (Python):
from collections import defaultdict,deque
from sys import stdin,setrecursionlimit
import heapq,bisect,math,itertools,string,queue,datetime,copy
setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, stdin.readline().split()))

s = str(input())

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

Solution (Python):
a = input()
print("A" if str.isupper(a) else "a")

Solution (Python):
a = input()
if a==a.lower():
    print("a")
else:
    print("A")

Solution (Python):
a = input()
if a.isupper():
  print("A")
else:
  print("a")

Solution (Python):
S = input()
print("A" if S == S.upper() else "a")

Solution (Python):
import sys
sys.setrecursionlimit(10**9)

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

def main():
    a = input()

    if ord('A') <= ord(a) <= ord('Z'):
        print('A')
    else:
        print('a')




if __name__ == "__main__":
  main()

Solution (Python):
import sys
import itertools

import time
import math
 
sys.setrecursionlimit(10 ** 7)
 
from collections import defaultdict
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines




n = input()

if ord(n) < 97:
    print('A')
else:
    print('a')

Solution (Python):

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

Solution (Python):
S = input()
if S.isupper():
    print("A")
else:
    print("a")

Solution (Python):
s = input()
abc = ['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']
if s in abc:
    print('a')
else:
    print('A')

Solution (Python):
S=input()
if(S==S.upper()):
  print("A")
else:
  print("a")

Solution (Python):
import string
import sys


def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return input()
def LS(): return input().split()


a = S()
if a in string.ascii_lowercase:
    print('a')
else:
    print('A')

Solution (Python):
S = input()
if S == S.upper():
    print("A")
else:
    print("a")

Solution (Python):
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction

sys.setrecursionlimit(int(pow(10,6)))


mod = int(pow(10, 9) + 7)
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]



s=input()
if s==s.lower():
    print("a")
else:
    print("A")

Solution (Python):
a = input()
if a.isupper():
    print("A")
else:
    print("a")

Solution (Python):


S = input()

if S.isupper():
    print('A')
else:
    print('a')

Solution (Python):
low = "qwertyuioplkjhgfdsazxcvbnm"
hig = "QWERTYUIOPLKJHGFDSAZXCVBNM"
a = input()
if a in low:
  print("a")
else:
  print("A")

Solution (Python):
a = input()
if a in [chr(i) for i in range(97, 97+26)]:
    print("a")
else:
    print('A')

Solution (Python):
s = input()

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

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

Solution (Python):
a = input()
if a == a.lower():
    print("a")
else:
    print("A")

Solution (Python):
import sys
import math
import itertools as it
def I():return int(sys.stdin.readline().replace("\n",""))
def I2():return map(int,sys.stdin.readline().replace("\n","").split())
def S():return str(sys.stdin.readline().replace("\n",""))
def L():return list(sys.stdin.readline().replace("\n",""))
def Intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace("\n","").split()))

if __name__ == "__main__":
    s = S()
    print("A" if s.upper() == s else "a")

Solution (Python):


x = input()
if x.lower() == x:
    print('a')
else:
    print('A')

Solution (Python):
print("a" if input().islower() else "A")

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

Solution (Python):
c = input()

if c.isupper():
    print("A")
else:
    print("a")

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

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

Solution (Python):
a = input()
if a.isupper():
    print("A")
else:
    print("a")

Solution (Python):
s = input()
if s.islower():
    print("a")
else:
    print("A")

Solution (Python):
s = input()

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

Solution (Python):
import sys
input = sys.stdin.readline

'''

'''

a = input().strip()

if a.islower():
    print("a")
else:
    print("A")

Solution (Python):
a = input()
if str.upper(a) == a:
    print("A")
else:
    print("a")

Solution (Python):
def main():
    a = input()
    if ord("a") <= ord(a) <= ord("z"):
        print("a")
    else:
        print("A")

if __name__ == "__main__":
    main()

Solution (Python):

import sys
input = sys.stdin.readline
ipnl = lambda n: [int(input()) for _ in range(n)]
inp = lambda :int(input())
ip = lambda :[int(w) for w in input().split()]

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

Solution (Python):
S = input()

if S.isupper():
    print("A")
else:
    print("a")

Solution (Python):
import math  
from typing import Dict, List, Optional, Tuple, Union  


def main(a: str):
    print(["A", "a"][a.islower()])


if __name__ == "__main__":
    a = input()
    main(a)

Solution (Python):
alpha = input()
if 'A' <= alpha <= 'Z':
    print('A')
else:
    print('a')

Solution (Python):
X=input()
if X==X.lower():
    print("a")
else:
    print("A")

Solution (Python):

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

Solution (Python):
x = input()
if x.upper() == x:
    print("A")
else:
    print("a")

Solution (Python):
a = input()
if ord('a') <= ord(a) <= ord('z'):
  print('a')
else:
  print('A')

Solution (Python):
a = input()
K = ord(a)
if K < 97:
  print("A")
else:
  print("a")

Solution (Python):
a = input()
if ord('A') <= ord(a) <= ord('Z'):
  print('A')
else:
  print('a')

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

Solution (Python):

def q1():
    c = input()
    if c.isupper():
        print('A')
    else:
        print('a')


q1()

Solution (Python):
import sys
read = sys.stdin.read
readline = sys.stdin.buffer.readline
INF = float('inf')


def main():
    s = readline().decode('utf-8')
    if s.isupper():
        print('A')
    else:
        print('a')


if __name__ == '__main__':
    main()

Solution (Python):
a = input()

if a.isupper():
    print("A")
else:
    print("a")

Solution (Python):
a = input()
if "a" <= a <= "z":
  print("a")
else:
  print("A")

Solution (Python):
s = input()

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

Solution (Python):
s = input()
if(s == s.lower()):print("a")
else:print("A")

Solution (Python):
a = input()
if a == a.lower(): print("a")
else: print("A")

Solution (Python):
a = input()
if ord("a") <= ord(a) <= ord("z"):
    print("a")
else:
    print("A")