Problem:
 Score : 100 points    Problem Statement On the Planet AtCoder, there are four types of bases: A , C , G and T . A bonds with T , and C bonds with G .  You are given a letter b as input, which is A , C , G or T . Write a program that prints the letter representing the base that bonds with the base b .      Constraints  b is one of the letters A , C , G and T .         Input Input is given from Standard Input in the following format:  b       Output Print the letter representing the base that bonds with the base b .        Sample Input 1 A      Sample Output 1 T       Sample Input 2 G      Sample Output 2 C

Solution (Python):
star = {"A":"T", "C":"G", "T":"A", "G":"C"}
hoshi = input()
print(star[hoshi])

Solution (Python):
d = {"A":"T","T":"A","C":"G","G":"C"}
print(d[input()])

Solution (Python):
b = input()
if b == "A":
  b = "T"
elif b == "T":
  b = "A"
elif b == "C":
  b = "G"
elif b == "G":
  b = "C"
print(b)

Solution (Python):
b = input()
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
else:
    print("C")

Solution (Python):
b = input()
if b == 'A':
  print('T')
elif b == 'C':
  print('G')
elif b == 'G':
  print('C')
else:
  print('A')

Solution (Python):
b = input()
d = {
    "A": "T",
    "T": "A",
    "G": "C",
    "C": "G"
}

print(d[b])

Solution (Python):
b = str(input())
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "G":
    print("C")
else:
    print("G")

Solution (Python):
b = input()
acid = {"A":"T","T":"A","G":"C","C":"G"}
print(acid[b])

Solution (Python):
dna={"A":"T", "T":"A", "C":"G", "G":"C"}
print(dna[input()])

Solution (Python):
b = input()
if b == "A":
  print("T")
elif b == "C":
  print("G")
elif b == "T":
  print("A")
elif b == "G":
  print("C")

Solution (Python):
b = input()

if b == 'A':
    print('T')
elif b == 'T':
    print('A')
elif b == 'C':
    print('G')
else:
    print('C')

Solution (Python):
print({'A':'T','T':'A','C':'G','G':'C'}[input()])

Solution (Python):



b = input()


if b == 'A':
    ans = 'T'
elif b  == 'T':
    ans = 'A'
elif b == 'C':
    ans = 'G'
else:
    ans = 'C'


print(ans)

Solution (Python):
b = input()

if b == 'A':
    print('T')
elif b == 'T':
    print('A')
elif b == 'C':
    print('G')
elif b == 'G':
    print('C')

Solution (Python):
b = input()
if b == "A":
    print("T")
if b == "T":
    print("A")
if b == "G":
    print("C")
if b == "C":
    print("G")

Solution (Python):
b = input()

out ={"A":"T", "C":"G", "G":"C", "T":"A"}

print(out[b])

Solution (Python):
b=input()

if b=="A":
    print("T")
elif b=="T":
    print("A")
elif b=="G":
    print("C")
elif b=="C":
    print("G")

Solution (Python):
a = input()
if a is "A":
  print("T")
if a is "T":
  print("A")
if a is "G":
  print("C")
if a is "C":
  print("G")

Solution (Python):
b=input()
print('A' if b=='T' else 'T' if b=='A' else 'C' if b=='G' else 'G')

Solution (Python):
d = input()
if d == 'A':
  print('T')
elif d == 'T':
  print('A')
elif d == 'G':
  print('C')
elif d == 'C':
  print('G')

Solution (Python):
print({"A":"T","T":"A","G":"C","C":"G"}[input()])

Solution (Python):
print(*["A" if x=="T" else "T" if x=="A" else "C" if x=="G" else "G" for x in str(input())])

Solution (Python):
s = input()

dict = {'A': 'T', 'C': 'G', 'T': 'A', 'G': 'C'}
print(dict[s])

Solution (Python):
b = input()
if b == "A":
    print("T")
elif b == "T":
    print("A") 
elif b == "C":
    print("G") 
elif b == "G":
    print("C")

Solution (Python):
b = input()


if b == "A":
    print("T")
elif b == "C":
    print("G")
elif b == "G":
    print("C")
else:
    print("A")

Solution (Python):
b = input()
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
else:
    print("C")

Solution (Python):
b = input()
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
else:
    print("C")

Solution (Python):
def main():

    """ convenient functions
    
    
    
    
    
    """

    """convenient decorator
    
    
        
        
        
        
        
        
        
        
        
        
    """
    
    
    import sys
    sys.setrecursionlimit(10**7)
    from itertools import accumulate, combinations, permutations, product 
    
    from math import factorial, ceil, floor, sqrt
    def factorize(n):
        """return the factors of the Arg and count of each factor
        
        Args:
            n (long): number to be resolved into factors
        
        Returns:
            list of tuples: factorize(220) returns [(2, 2), (5, 1), (11, 1)]
        """
        fct = []  
        b, e = 2, 0  
        while b * b <= n:
            while n % b == 0:
                n = n // b
                e = e + 1
            if e > 0:
                fct.append((b, e))
            b, e = b + 1, 0
        if n > 1:
            fct.append((n, 1))
        return fct
    def combinations_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        
        if n < 0 or r < 0:
            raise Exception('combinations_count(n, r) not defined when n or r is negative')
        if n - r < r: r = n - r
        if r < 0: return 0
        if r == 0: return 1
        if r == 1: return n
        numerator = [n - r + k + 1 for k in range(r)]
        denominator = [k + 1 for k in range(r)]
        for p in range(2,r+1):
            pivot = denominator[p - 1]
            if pivot > 1:
                offset = (n - r) % p
                for k in range(p-1,r,p):
                    numerator[k - offset] /= pivot
                    denominator[k] /= pivot
        result = 1
        for k in range(r):
            if numerator[k] > 1:
                result *= int(numerator[k])
        return result
    def combinations_with_replacement_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items allowing individual elements to be repeated more than once.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        if n < 0 or r < 0:
            raise Exception('combinations_with_replacement_count(n, r) not defined when n or r is negative')
        elif n == 0:
            return 1
        else:
            return combinations_count(n + r - 1, r)
    from bisect import bisect_left, bisect_right
    from collections import deque, Counter, defaultdict 
    from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest 
    from copy import deepcopy, copy 
    import operator
    from operator import itemgetter
    
    
    from functools import reduce, lru_cache
    def chmin(x, y):
        """change minimum
        if x > y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current minimum value
            y (long): potential minimum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x > y:
            x = y
            return (x, True)
        else:
            return (x, False)
    def chmax(x, y):
        """change maximum
        if x < y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current maximum value
            y (long): potential maximum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x < y:
            x = y
            return (x, True)
        else:
            return (x, False)

    from fractions import gcd 
    def gcds(numbers):
        return reduce(gcd, numbers)
    def lcm(x, y):
        return (x * y) // gcd(x, y)
    def lcms(numbers):
        return reduce(lcm, numbers, 1)

    
    
    INF = 10 ** 18
    MOD = 10 ** 9 + 7
    modpow = lambda a, n, p = MOD: pow(a, n, p) 
    def modinv(a, p = MOD):
        
        
        return modpow(a, p-2, p)
    def modinv_list(n, p = MOD):
        if n <= 1:
            return [0,1][:n+1]
        else:
            inv_t = [0,1]
            for i in range(2, n+1):
                inv_t += [inv_t[p % i] * (p - int(p / i)) % p]
            return inv_t
    def modfactorial_list(n, p = MOD):
        if n == 0:
            return [1]
        else:
            l = [0] * (n+1)
            tmp = 1
            for i in range(1, n+1):
                tmp = tmp * i % p
                l[i] = tmp
            return l
    def modcomb(n, k, fac_list = [], p = MOD):
        
        
        from math import factorial
        if n < 0 or k < 0 or n < k: return 0
        if n == 0 or k == 0: return 1
        if len(fac_list) <= n:
            a = factorial(n) % p
            b = factorial(k) % p
            c = factorial(n-k) % p
        else:
            a = fac_list[n]
            b = fac_list[k]
            c = fac_list[n-k]
        return (a * modpow(b, p-2, p) * modpow(c, p-2, p)) % p
    def modadd(a, b, p = MOD):
        return (a + b) % MOD
    def modsub(a, b, p = MOD):
        return (a - b) % p
    def modmul(a, b, p = MOD):
        return ((a % p) * (b % p)) % p
    def moddiv(a, b, p = MOD):
        return modmul(a, modpow(b, p-2, p))

    """ initialize variables and set inputs
    
        
        
    
        
        
        
        
        
    
        
        
        
        
    
        
        
    """

    
    r = lambda: sys.stdin.readline().strip()
    r_int = lambda: int(r())
    R = lambda: list(map(int, r().split()))
    Rmap = lambda: map(int, r().split())
    Rfloat = lambda: list(map(float, r().split()))
    Rtuple = lambda: tuple(map(int, r().split()))

    """ how to treat input
    
    
    
    
    
    
    
    """

    if __name__ != '__main__':
        
        sys.stdin = open('sample.txt')

    
    

    b = r()
    if b == 'A':
        print('T')
    elif b == 'T':
        print('A')
    elif b == 'G':
        print('C')
    else:
        print('G')
    
    
    

    """memo: how to use defaultdict of list
    
    Dic = defaultdict(list)
    
    Dic[x].append(y)
    
    for k, v in Dic.items():
    """

if __name__ == '__main__':
    main()

Solution (Python):
b = input()
d = {'A':'T', 'T':'A', 'G':'C', 'C':'G'}
print(d[b])

Solution (Python):
b = input()
if b == 'A':
    print('T')
elif b == 'T':
    print('A')
elif b == 'C':
    print('G')
else:
    print('C')

Solution (Python):
d = {"A": "T", "G": "C", "T": "A", "C": "G"}
print(d[input()])

Solution (Python):
b = input()

if b == "A":
    print("T")

if b == "T":
    print("A")

if b == "G":
    print("C")

if b == "C":
    print("G")

Solution (Python):
print({"A": "T", "C": "G", "T": "A", "G": "C"}[input()])

Solution (Python):
def f(b):
  dictionary = {'A':'T','T':'A','C':'G','G':'C'}
  print(dictionary[b])

b = input()

f(b)

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

if b == 'A':
    print("T")
elif b == 'T':
    print("A")
elif b == 'C':
    print("G")
else:
    print("C")

Solution (Python):
b = input()
if b == 'G':
  print('C')
elif b == 'C':
  print('G')
elif b == 'A':
  print('T')
else:
  print('A')

Solution (Python):
if __name__ == '__main__':
    
    b = input()
    if b == 'A':
        print('T')
    elif b == 'T':
        print('A')
    elif b == 'G':
        print('C')
    else:
        print('G')

Solution (Python):
ACGT = ['A', 'C', 'T', 'G']
X = input()
for i in range(0, 4):
	if ACGT[i] == X:
		print(ACGT[(i+2)%4])

Solution (Python):
b = input()

if b == "A":
	print("T")
elif b == "T":
	print("A")
elif b == "C":
	print("G")
else:
	print("C")

Solution (Python):
b = input()

if b == 'A':
    print("T")
elif b == 'C':
    print("G")
elif b == 'T':
    print("A")
else:
    print("C")

Solution (Python):
a = input()
b = {"A": "T", "T": "A", "C": "G","G": "C"}
print(b[a])

Solution (Python):

b=str(input())
if b == "A":
    print("T")
elif b == "C":
    print("G")
elif b == "G":
    print("C")
elif b == "T":
    print("A")

Solution (Python):
b = input()

if b == 'A':
    print('T')
if b == 'T':
    print('A')
if b == 'C':
    print('G')
if b == 'G':
    print('C')

Solution (Python):
b = input()

bases = ('A', 'C', 'G', 'T')

for idx, base in enumerate(bases):
  if base == b:
    print(bases[int(~(idx))])
    break

Solution (Python):
b=input()

if b == 'A':
    print('T')
elif b == 'T':
    print('A')
elif b == 'G':
    print('C')
elif b == 'C':
    print('G')
else:
    pass

Solution (Python):
b=input()
if b=="A":
    print("T")
elif b=="T":
    print("A")
elif b=="C":
    print("G")
else:
    print("C")

Solution (Python):
b = input()
enki = {"A":"T", "C":"G", "G":"C", "T":"A"}
print(enki[b]) if b in enki else print()

Solution (Python):
s = input()
if s=='A':
  print('T')
if s=='T':
  print('A')
if s=='G':
  print('C')
if s=='C':
  print('G')

Solution (Python):
s=input()
if s=="A":
      print("T")
elif s=="C":
      print("G")
elif s=="T":
      print("A")
elif s=="G":
      print("C")

Solution (Python):
x=input()
if x=='A':
  print('T')
elif x=='T':
  print('A')
elif x=='G':
  print('C')
else:
  print('G')

Solution (Python):
print({'A':'T','T':'A','C':'G','G':'C'}[input()])

Solution (Python):
def main():
    b = input()
    if b == 'A':
        print('T')
    elif b == 'T':
        print('A')
    elif b == 'G':
        print('C')
    else:
        print('G')


main()

Solution (Python):
b = raw_input()
if b == "A":
    print "T"
elif b == "T":
    print "A"
if b == "C":
    print "G"
elif b == "G":
    print "C"

Solution (Python):
b = input()
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
else:
    print("C")

Solution (Python):
b = input()
 
c = {"A":"T","T":"A","C":"G","G":"C"}
 
print(c[b])

Solution (Python):
b = input()

if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
else:
    print("C")

Solution (Python):
b = input()

if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
else:
    print("C")

Solution (Python):
b=input()

if b=="A":
	print("T")
elif b=="T":
	print("A")
elif b=="C":
	print("G")
elif b=="G":
	print("C")

Solution (Python):
import sys

def input(): return sys.stdin.readline()[:-1]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def MATINT(h): return [list(map(int, input().split())) for _ in range(h)]
def MATSTR(h): return [input() for _ in range(h)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
inf = float('inf')
mod = 10 ** 9 + 7

def main():
    S = input()
    if S == 'A':
        print('T')
    elif S == 'T':
        print('A')
    elif S == 'C':
        print('G')
    elif S == 'G':
        print('C')

if __name__ == '__main__':
    main()

Solution (Python):
a = input()
b = [["A", "T"], ["T", "A"], ["C", "G"], ["G", "C"]]
for i in range(4):
    if b[i][0] == a:
        print(b[i][1])
        exit()

Solution (Python):
c = input()
if c == "A":
    print("T")
elif c == "T":
    print("A")
elif c == "G":
    print("C")
elif c == "C":
    print("G")

Solution (Python):
def main():
    k = input()
    if k == "A":
        print("T")
    if k == "T":
        print("A")
    if k == "C":
        print("G")
    if k == "G":
        print("C")


if __name__ == "__main__":
    main()

Solution (Python):
dic = {'A':'T', 'C':'G', 'G':'C', 'T':'A'}
b = input()

print(dic[b])

Solution (Python):
a = input()
dic = {'A' : 'T',
       'C' : 'G',
       'G' : 'C',
       'T' : 'A'}
print(dic[a])

Solution (Python):
def A(n):
    dic = {"A":"T","T":"A","G":"C","C":"G"}
    return dic[n]

b = input()
print(A(b))

Solution (Python):
b = input()

t = {
    'A': 'T',
    'T': 'A',
    'C': 'G',
    'G': 'C',
}

print(t[b])

Solution (Python):
b = str(input())
if b == 'A':
  print('T')
elif b == 'T':
  print('A')
elif b == 'G':
  print('C')
else:
  print('G')

Solution (Python):
d = {"A":"T","T":"A","G":"C","C":"G"}
print(d[str(input())])

Solution (Python):
b=input()
l=['A','T','C','G']
for i in range(4):
	t=l.index(b)+i
	if t==1:
		print(l[i])
	elif t==5:
		print(l[i])

Solution (Python):
dna={"A":"T", "T":"A", "C":"G", "G":"C"}
print(dna[input()])

Solution (Python):
b = input()
dict = {'A':'T', 'T':'A', 'C':'G', 'G':'C'}
print(dict[b])

Solution (Python):
b=input()
if b=='A':
    print('T')
elif b=='T':
    print('A')
elif b=='C':
    print('G')
else:
    print('C')

Solution (Python):
a = input()
b = {"A":"T","T":"A","C":"G","G":"C"}
print(b[a])

Solution (Python):
b = input()

if b == 'A':
  print("T")
elif b == 'C':
  print("G")
elif b == 'G':
  print("C")
elif b == 'T':
  print("A")

Solution (Python):
v = input()
if v == "A":
  print("T")
elif v == "T":
  print("A")
elif v == "C":
  print("G")
elif v == "G":
  print("C")

Solution (Python):
b = input()

if b == 'A': print('T')
elif b == 'T': print('A')
elif b == 'G': print('C')
else: print('G')

Solution (Python):
a = input()
if(a=="A"):
	print("T")
elif(a=="T"):
	print("A")
elif(a=="G"):
	print("C")
else:
	print("G")

Solution (Python):
b=input()
if b=='A':
  print('T')
elif b=='T':
  print('A')
elif b=='G':
  print('C')
else:
  print('G')

Solution (Python):
b = input()
if b=='A':
    print('T')
elif b=='C':
    print('G')
elif b=='G':
    print('C')
else:
    print('A')

Solution (Python):

b = input()
if b == "T":
    print("A")
elif b == "A":
    print("T")
elif b == "C":
    print("G")
else:
    print("C")

Solution (Python):
b = input()
if b == 'A':
    print('T')
elif b == 'T':
    print('A')
elif b == 'C':
    print('G')
elif b == 'G':
    print('C')

Solution (Python):
S = input()
if S=="A":
    set="set_A"
if S=="C":
    set="set_C"
if S=="G":
    set="set_G"
if S=="T":
    set="set_T"

if set == "set_A":
    ans = "T"
if set == "set_C":
    ans = "G"
if set == "set_G":
    ans = "C"
if set == "set_T":
    ans = "A"
print(ans)

Solution (Python):
b = input()
if b == 'A':
    print('T')
elif b == 'T':
    print('A')

if b == 'G':
    print('C')
elif b == 'C':
    print('G')

Solution (Python):
b = input()
if b == "A":
  print("T")
elif b =="T":
  print("A")
elif b =="C":
  print("G")
else:
  print("C")

Solution (Python):
b = input()

if b == "A":
    print("T")
elif b == "C":
    print("G")
elif b == "G":
    print("C")
else:
    print("A")

Solution (Python):
b = input()
c = ['A','T','C','G']
if b==c[0]:
    print(c[1])
elif b==c[1]:
    print(c[0])
elif b==c[2]:
    print(c[3])
else:
    print(c[2])

Solution (Python):
b = input()
if b =='A':
  print('T')
elif b == 'T':
  print('A')
elif b == 'C':
  print('G')
else:
  print('C')

Solution (Python):
n=input()
if n=='A':
    print('T')
elif n=='G':
    print('C')
elif n=='T':
    print('A')
else:
    print('G')

Solution (Python):
b = input()
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
else:
    print("C")

Solution (Python):
from sys import stdin

b = stdin.readline().rstrip()

if b == 'A':
    print('T')
if b == 'T':
    print('A')
if b == 'G':
    print('C')
if b == 'C':
    print('G')

Solution (Python):
S = str(input())
 
if S == 'A':
  print('T')
elif S == 'G':
  print('C')
elif S == 'T':
  print('A')
else:
  print('G')

Solution (Python):
b = input()
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
else:
    print("C")

Solution (Python):
b=input()
if b=="A":
  print("T")
elif b=="T":
  print("A")
elif b=="C":
  print("G")
else:
  print("C")

Solution (Python):
a = input()
dic = {'A':'T','T':'A','G':'C','C':'G'}
print(dic[a])

Solution (Python):
enki_a = ['A','T']
enki_b = ['C','G']

b = input()

if b in enki_a:
  enki_a.remove(b)
  print(''.join(enki_a))
elif b in enki_b:
  enki_b.remove(b)
  print(''.join(enki_b))

Solution (Python):
Enki = {'A':'T','T':'A','C':'G','G':'C'}
print(Enki[input()])

Solution (Python):
b=str(input())
if b=='A':
  print('T')
elif b=='T':
  print('A')
elif b=='C':
  print('G')
else :
  print('C')

Solution (Python):


b = input()

print("A" if (b == "T") else "T" if (b == "A") else "C" if (b == "G") else "G")

Solution (Python):


b = input()

print("A" if (b == "T") else "T" if (b == "A") else "C" if (b == "G") else "G")

Solution (Python):
b = input()
print(b.replace('A','a').replace('T','t').replace('C','c').replace('G','g').replace('a','T').replace('t','A').replace('c','G').replace('g','C'))

Solution (Python):
b = input()
if b == 'A':
    print('T')
if b == 'T':
    print('A')
if b == 'G':
    print('C')
if b == 'C':
    print('G')

Solution (Python):
b = input()
 
dict = {"A":"T","C":"G","T":"A","G":"C"}
 
print(dict[b])

Solution (Python):
s=input()
print(s.translate(str.maketrans({'A': 'T', 'T': 'A','C': 'G', 'G': 'C'})))

Solution (Python):
enki = {"A":"T","T":"A","C":"G","G":"C"}
B= input()
print(enki[B])

Solution (Python):
d = {"A" : "T", "G" : "C", "T" : "A", "C" : "G"}
print(d[input()])

Solution (Python):
d = {"A" : "T", "G" : "C", "T" : "A", "C" : "G"}
print(d[input()])

Solution (Python):
b=input()
l=[['A','T'],['C','G']]
for i in range(2):
    if b==l[i][0]:
        print(l[i][1])
        break
    elif b==l[i][1]:
        print(l[i][0])
        break

Solution (Python):
b = input()
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
elif b == "G":
    print("C")

Solution (Python):
a=input()
s={"A":"T","T":"A","C":"G","G":"C"}
print(s[a])

Solution (Python):
b = input()

if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
elif b == "G":
    print("C")
else:
    print(b)

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

if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "G":
    print("C")
elif b == "C":
    print("G")

Solution (Python):
B=input()
W="TACG"
N="ATGC".find(B)

print(W[N])

Solution (Python):
b=input()
if b == 'A':
    print('T')
elif b == 'T':
    print('A')
elif b == 'C':
    print('G')
else:
    print('C')

Solution (Python):
b = str(input())
sample = ["A", "C", "G", "T"]
ans = ["T", "G", "C", "A"]
print(ans[sample.index(b)])

Solution (Python):
ans = {'A':'T', 'T':'A', 'C':'G', 'G':'C'}
print(ans[input()])

Solution (Python):
x = input()
if x == "A":
    print("T")
elif x == "T":
    print("A")
elif x == "C":
    print("G")
else:
    print("C")

Solution (Python):
b=input()

A="A"
C="C"
G="G"
T="T"

if b == A:
    print("T")
    
elif b==C:
    print("G")
    
elif b==G:
    print("C")
    
elif b==T:
    print("A")

Solution (Python):
b = input()
A = 'A'
C = 'C'
G = 'G'
T = 'T'
if b == A:
  print(T)
elif b == C:
  print(G)
elif b == G:
  print(C)
else:
  print(A)

Solution (Python):
b = input()
if b == 'A':
  print('T')
elif b == 'T':
  print('A')
elif b == 'G':
  print('C')
elif b == 'C':
  print('G')

Solution (Python):
word = input()

enki = {'A':'T','T':'A','C':'G','G':'C'}
print(enki[word])

Solution (Python):
s1 = input()

r1 = ""
if s1 == "A":
    r1 = "T"
elif s1 == "C":
    r1 = "G"
elif s1 == "T":
    r1 = "A"
else:
    r1 = "C"

print(r1)

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

if(b == "A"):
    print("T")
elif(b == "T"):
    print("A")
elif(b == "G"):
    print("C")
elif(b == "C"):
    print("G")

Solution (Python):


b=input()
if b=="A":
	print("T")
elif b=="T":
	print("A")
elif b=="C":
	print("G")
else:
	print("C")

Solution (Python):
b = input()
if b == "A":
    print("T")
elif  b =="T":
    print("A")
elif b =="G":
    print("C")
else:
    print("G")

Solution (Python):
X = input()

if X == "A":
    print("T")
if X == "T":
    print("A")
if X == "C":
    print("G")
if X == "G":
    print("C")

Solution (Python):
print("TGCA"["ACGT".find(input())])

Solution (Python):
b = input()
if b == 'A':
    print('T')
elif b == 'C':
    print('G')
elif b == 'G':
    print('C')
elif b == 'T':
    print('A')

Solution (Python):
b=input()
if b=='A':
    print('T')
elif b=='T':
    print('A')
elif b=='G':
    print('C')
elif b=='C':
    print('G')

Solution (Python):
b=str(input())
if b=='C': 
    print('G')
elif b=='G':
    print('C')
elif b=='A':
    print('T')
else:
    print('A')

Solution (Python):
b = input()

if b == 'A':
    print('T')
elif b == 'T':
    print('A')
elif b == 'G':
    print('C')
elif b == 'C':
    print('G')

Solution (Python):
print("TGCA"["ACGT".find(input())])

Solution (Python):
s = input()

if s == 'A':
  print('T')
elif s == 'T':
  print('A')
elif s == 'G':
  print('C')
else:
  print('G')

Solution (Python):
x = input()
if x == "A":
    print("T")
elif x == "T":
    print("A")
elif x == "C":
    print("G")
else:
    print("C")

Solution (Python):
b = input()

if b is "A":
    print("T")

if b is "T":
    print("A")

if b is "C":
    print("G")

if b is "G":
    print("C")

Solution (Python):
def abc():
    mapping = {
        'A': 'T',
        'C': 'G',
        'G': 'C',
        'T': 'A',
    }
    b = input().rstrip()
    print(mapping[b])


abc()

Solution (Python):
b=input()

if(b=="A"):
    print("T")
elif(b=="T"):
    print("A")
elif(b=="G"):
    print("C")
else:
    print("G")

Solution (Python):
s = input()
print('A' if s == 'T' else 'T' if s == 'A' else 'C' if s == 'G' else 'G')

Solution (Python):
s = input()
print('A' if s == 'T' else 'T' if s == 'A' else 'C' if s == 'G' else 'G')

Solution (Python):
c = input()
di = {"A":"T","T":"A","G":"C","C":"G"}
print(di[c])

Solution (Python):
print({"A":"T","T":"A","C":"G","G":"C"}[input()])

Solution (Python):
b = input()
d = {"A": "T", "T": "A", "C": "G", "G": "C"}
print(d[b])

Solution (Python):
b = input()
if b == "A":
  print("T")
elif b == "T":
  print("A")
elif b == "G":
  print("C")
else:
  print("G")

Solution (Python):
b = input()
dic = {'A':'T', 'C':'G', 'G':'C', 'T':'A'}
print(dic[b])

Solution (Python):
import sys


for line in sys.stdin.readlines():
    line=line.strip()
    if line == 'A':
        print('T')
    if line == 'T':
        print('A')
    if line == 'C':
        print('G')
    if line == 'G':
        print('C')

Solution (Python):



import sys

input = sys.stdin.readline

def main():
    m = {"A": "T", "T": "A", "G": "C", "C": "G"}
    print(m[input().strip()])

main()

Solution (Python):
b = input()
dic = {'A':'T','T':'A','C':'G','G':'C'}
print(dic[b])

Solution (Python):
b=input()

if b=="A":
    print("T")
elif b=="C":
    print("G")
elif b=="G":
    print("C")
else:
    print("A")

Solution (Python):
import sys

b=input()
if b=='A':
    print('T')
elif b=='T':
    print('A')
elif b=='C':
    print('G')
elif b=='G':
    print('C')
else :
    sys.exit()

Solution (Python):
b = input()
if b == 'A':
  print('T')
elif b == 'T':
  print('A')
elif b == 'G':
  print('C')
else:
  print('G')

Solution (Python):
d=input()
if d=='A':
  o='T'
elif d=='T':
  o='A'
elif d=='C':
  o='G'
else :
  o='C'
print(o)

Solution (Python):
base_pair = {
    "A": "T",
    "T": "A",
    "G": "C",
    "C": "G"
}
print(base_pair[input()])

Solution (Python):
def resolve():
    dic={'A':'T','T':'A','C':'G','G':'C'}

    b=input()
    print(dic[b])


resolve()

Solution (Python):
b = input()

if "A" == b:
    print("T")
elif "C" == b:
    print("G")
elif "G" == b:
    print("C")
else:
    print("A")

Solution (Python):
b = input()
dic = {'A':'T','C':'G','T':'A','G':'C'}
print(dic.get(b))

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

if b == 'A':
    print('T')

if b == 'T':
    print('A')

if b == 'C':
    print('G')

if b == 'G':
    print('C')

Solution (Python):
b=input()
if b=="A":
  print("T")
elif b=="T":
  print("A")
elif b=="G":
  print("C")
elif b=="C":
  print("G")

Solution (Python):
s = input()
if(s == 'T'):
  print("A")
elif(s == 'G'):
  print("C")
elif(s == 'C'):
  print("G")
else:
  print("T")

Solution (Python):
b=input()

if b=="A":
    print("T")
elif b=="T":
    print("A")
elif b=="C":
    print("G")
else:
    print("C")

Solution (Python):
B={"A":"T","T":"A","C":"G","G":"C"}
b=input()
print(B[b])

Solution (Python):
s = input()

if s == 'A' :
    print('T')
if s == 'T' :
    print('A')
if s == 'C' :
    print('G')
if s == 'G' :
    print('C')

Solution (Python):
b = input()

if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "G":
    print("C")
else:
    print("G")

Solution (Python):
b = input()

if b == "A":
    print("T")
if b == "T":
    print("A")
if b == "C":
    print("G")
if b == "G":
    print("C")

Solution (Python):
s="ATACGC";print(s[s.index(input())+1])

Solution (Python):


'''
allinputs = iter(input().splitlines())
input = lambda : next(allinputs)


c = str(input())
if c == 'A':
	print('T')
elif c == 'T':
	print('A')
elif c == 'C':
	print('G')
else:
	print('C')

Solution (Python):
inp = input()
if inp == "A":
    print("T")
elif inp == "T":
    print("A")
elif inp == "G":
    print("C")
else:
    print("G")

Solution (Python):
b = input()

if b == 'A':
    print('T')
elif b == 'T':
    print('A')
elif b == 'C':
    print('G')
elif b == 'G':
    print('C')

Solution (Python):


b = input()

if b == 'A':
    print('T')
elif b == 'T':
    print('A')
elif b == 'C':
    print('G')
elif b == 'G':
    print('C')

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

if b == "A":
  print("T")
elif b=="C":
  print("G")
elif b=="G":
  print("C")
else:
  print("A")

Solution (Python):
b = input()
if b == 'A':
  print('T')
elif b == 'T':
  print('A')
elif b == 'C':
  print('G')
elif b == 'G':
  print('C')

Solution (Python):

a = input()

if a =='A':
  print('T')
elif a =='T':
  print('A')
elif a == 'G':
  print('C')
elif a == 'C':
  print('G')

Solution (Python):
name = input()
if name == 'A':
  print('T')
elif name == 'T':
  print('A')
elif name == 'G':
  print('C')
elif name == 'C':
  print('G')

Solution (Python):
b = input()

if b == 'A':
  print('T')

elif b == 'T':
  print('A')

elif b == 'C':
  print('G')
  
else:
  print('C')

Solution (Python):
b = input()
if b == "A":
  print("T")
elif b == "T":
  print("A")
elif b == "C":
  print("G")
else:
  print("C")

Solution (Python):
ch = input()
if ch == "A":
    print("T")
elif ch == "T":
    print("A")
elif ch == "G":
    print("C")
elif ch == "C":
    print("G")

Solution (Python):
b=input()

if b=="A":
    print("T")

elif b=="C":
    print("G")

elif b=="T":
    print("A")

else:
    print("C")

Solution (Python):
b = input()
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
elif b == "G":
    print("C")

Solution (Python):
s = input()

if s == 'A':
  print('T')
elif s == 'T':
  print('A')
elif s == 'G':
  print('C')
elif s == 'C':
  print('G')

Solution (Python):
base = input()

if base == "a" or base == "A":
    print("T")
elif base == "t" or base == "T":
    print("A")
elif base == "c" or base == "C":
    print("G")
elif base == "g" or base == "G":
    print("C")

Solution (Python):


b=input()
if b=="A":
	print("T")
elif b=="T":
	print("A")
elif b=="C":
	print("G")
else:
	print("C")

Solution (Python):
b = input()

if(b == 'A'):
    print('T')
elif(b == 'T'):
    print('A')
elif(b == 'C'):
    print('G')
else:
    print('C')

Solution (Python):
b=input()
A={'A':"T", 'C':"G", 'G':"C", 'T':"A" }
print(A[b])

Solution (Python):
b=input()
print("A" if b=="T" else "T" if b=="A" else "C" if b=="G" else "G")

Solution (Python):
b = input()

print("A" if b == "T" else "T" if b == "A" else "C" if b == "G" else "G")

Solution (Python):
b = input()
if b == 'A':
    print('T')
elif b == 'T':
    print('A')
elif b == 'C':
    print('G')
else:
    print('C')

Solution (Python):
b = input()

if b == 'A':
    print('T')
elif b == 'T':
    print('A')
elif b == 'C':
    print('G')
else:
    print('C')