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

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")
else:
    print("C")

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):
d = {"A":"T","T":"A","C":"G","G":"C"}
print(d[input()])

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

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

Solution (Python):


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

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):
c = input()
if c == 'A':
	print('T')
elif c == 'T':
    print('A')
elif c == 'C':
    print('G')
else:
    print('C')

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

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

print(dict[b])

Solution (Python):
s=input()
ans1='AT'
ans2='GC'
if s in ans1:
    print(ans1.strip(s))
else:
    print(ans2.strip(s))

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 = 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=="A":
	print("T")
elif S=="T":
	print("A")
elif S=="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')
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):
d = {'A':'T', 'T':'A', 'C':'G', 'G':'C'}
print(d[input()])

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

Solution (Python):
def main():
    b = input()

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

if __name__ == '__main__':
    main()

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=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 == 'A':
    print('T')
if b == 'T':
    print('A')
if b == 'G':
    print('C')
if b == 'C':
    print('G')

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):
l1 = ['A', 'C', 'G', 'T']
l2 = ['T', 'G', 'C', 'A']
b = input()
print(l2[l1.index(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()
chk = 'ACGT'
if b == 'A':
  print(chk[3])
elif b == 'C':
  print(chk[2])
elif b == 'G':
  print(chk[1])
else:
  print(chk[0])

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 == "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):
b = input()

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

print(ans)

Solution (Python):
a = ["A", "G", "T", "C"]
b = input()
print(a[a.index(b)-2])

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

Solution (Python):
print( "ATCG" [ "TAGC".find(input())])

Solution (Python):
import sys
 
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda x: [na() for _ in range(x)]
ns = lambda: stdin.readline().rstrip()
nas = lambda: stdin.readline().split()

b = ns()
m = dict()
m["A"] = "T"
m["T"] = "A"
m["G"] = "C"
m["C"] = "G"
print(m[b])

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 == '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 == "A":
    print("T")
if b == "T":
    print("A")
if b == "G":
    print("C")
if b == "C":
    print("G")

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=input()
if b=="A":
  print("T")
elif b=="T":
  print("A")
elif b=="C":
  print("G")
else:
  print("C")

Solution (Python):
b = input()

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

print(ans)

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

Solution (Python):
N=input()
a="ACGT"
j=0
for i in range(4):
  if a[i]==N:
  	j=i  
print(a[3-j])

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

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

Solution (Python):




def main():
    B = input()
    D = {'A': 'T',
         'C': 'G',
         'G': 'C',
         'T': 'A'}
    print(D[B])


if __name__ == "__main__":
    main()

Solution (Python):
BASES = {"A":"T", "C":"G", "G":"C", "T":"A"}

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

Solution (Python):
b = input()

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

print(a[b])

Solution (Python):
b = input()
print(b.replace("A", "X").replace("T", "A").replace("X", "T").replace("C", "Y").replace("G", "C").replace("Y", "G"))

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 = 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 == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "G":
    print("C")
else:
    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):
import sys

INPUT = lambda: sys.stdin.readline().rstrip()

sys.setrecursionlimit(10 ** 9)


def main():
    b = INPUT()

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


if __name__ == '__main__':
    main()

Solution (Python):
b = input()

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

print("".join([enki[i] for i in b]))

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

Solution (Python):
b = input()
l = {"A":1,"C":2,"G":3,"T":4}

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

Solution (Python):
b = input()

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

Solution (Python):
b = input()

def enki(st):
    if st == 'A':
        return 'T'
    if st == 'T':
        return 'A'
    if st == 'G':
        return 'C'
    if st == 'C':
        return 'G'
       
print(enki(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=str(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 in "AT":
    print("AT"[b == "A"])
else:
    print("CG"[b == "C"])

Solution (Python):
b=str(input())
x=['A','C','G','T']
y=['T','G','C','A']
print(x[y.index(b)])

Solution (Python):
b = input()

dic = {"A":"T", "T":"A", "G":"C","C":"G"}
print(dic[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):
x=str(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=='A':
    print('T')
elif b=='T':
    print('A')
elif b=='C':
    print('G')
else:
    print('C')

Solution (Python):
b = input()
a = ["A", "T"]
c = ["C", "G"]
ans = ""

if b in a:
	a.remove(b)
	print("".join(a))
else:
	c.remove(b)
	print("".join(c))

Solution (Python):
b=str(input())
Enki=['A','C','G','T']
print(Enki[-Enki.index(b)-1])

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

Solution (Python):
b = input()
print( "AT".strip(b) if b == "A" or b == "T" else "CG".strip(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):
import sys
import math
import itertools

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 = ["T","G","C","A"]
c = ["A","C","G","T"]
b = str(input())
for i in range(len(s)):
  if(b == c[i]):
    print(s[i])

Solution (Python):
b = input()
l = [
    ('A', 'T'),
    ('T', 'A'),
    ('C', 'G'),
    ('G', 'C'),
]
for i, j in l:
    if i == b:
        print(j)

Solution (Python):
gene = {"A":"T","T":"A","C":"G","G":"C"}

print(gene[input()])

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

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

Solution (Python):
def read_values():
    return map(int, input().split())


def read_list():
    return list(read_values())


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


if __name__ == "__main__":
    main()

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

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

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

Solution (Python):
N = str(input())
if N == "A":
    print("T")
elif N == "T":
    print("A")
elif N == "G":
    print("C")
elif N == "C":
    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()
A=[["A","T"],["G","C"]]

for i in range(2):
    for j in range(2):
        if b==A[i][j]:
            print(A[i][(j+1)%2])

Solution (Python):
b=['A','T','A','C','G','C']
print(b[b.index(input())+1])

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

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

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

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

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

Solution (Python):
b=raw_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()
print("A" if b=="T" else "T" if b=="A" else "G" if b=="C" else "C")

Solution (Python):
n = str(input())
star = ["A","C","G","T"]
num = 0
for i in range(4):
    if n == star[i]:
        print(star[~i])
        break

Solution (Python):
dual = {
    'A': 'T',
    'C': 'G',
    'T': 'A',
    'G': 'C',
}

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

Solution (Python):
base = ["A","C","G","T"]
b = input()
n =  int(base.index(b))
print(base[3-n])

Solution (Python):
b = input()
stars = ['A', 'C', 'T', 'G']

ans = stars[(stars.index(b) + 2) % 4]

print(ans)

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

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


if __name__ == '__main__':
    main()

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

Solution (Python):
b=input()

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

Solution (Python):
"""
author : halo2halo
date : 15, Jan, 2020
"""

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

d = {'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G'}
b = readline().decode('utf8').split()
print(d[b[0]])

Solution (Python):
import sys

corresponding = dict(zip('ACGT', 'TGCA'))

b = sys.stdin.readline().rstrip()

def main():
    return corresponding[b]

if __name__ == '__main__':
    ans = main()
    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')
else:
    pass

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()

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

if __name__ == '__main__':
    main()

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():
    dic = {'A':'T', 'T':'A', 'G':'C', 'C':'G'}
    b = input()
    print(dic[b])
    
if __name__ == '__main__':
    main()

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

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):
a = {'A':'T','G':'C','C':'G','T':'A' }
s=input()
print(a[s])

Solution (Python):
b = input()
if(b == 'A' or b == 'T'):
    print('T' if b =='A' else 'A')
else:
    print('G' if b == 'C' else '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')
elif b == 'C':
  print('G')
elif b == 'G':
  print('C')
elif b == 'T':
  print('A')

Solution (Python):
a = input()

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

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

Solution (Python):
s = input()

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

print(dicG[s])

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 "G" if b=="C" else "C")

Solution (Python):
import sys
import math
import itertools
stdin = sys.stdin
mod = 10**9 + 7

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
sa = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a


def lcm(a, b):
    return a * b // gcd (a, b)

b = ns()

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 == 'T':
    print('A')
elif b == ('C'):
    print('G')
else :
    print('C')

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

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 == 'C'):
   print('G')
elif (b == 'G'):
   print('C')
else:
   print('A')

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input():
    return sys.stdin.readline().rstrip()

def main():
    d={'A':'T','T':'A','G':'C','C':'G'}
    print(d[input()])

if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):
b = input()
print(
    b.replace("A", "X").replace("T", "A").replace("X", "T").replace(
        "C", "Y").replace("G", "C").replace("Y", "G"))

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

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()
l=['A','C','G','T']
for i in range(4):
  if b==l[i]:
    print(l[3-i])

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

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

print(data[b])

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():
    dic={'A':'T','T':'A','G':'C','C':'G'}
    b=STR()
    print(dic[b])
if __name__ == '__main__':
    do()

Solution (Python):
S=input()  
if S=='A':
  print('T')
elif S=='C':
  print('G')
elif S=='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()
a={'A':'T','T':'A','G':'C','C':'G'}
print(a[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()
print("A" if b=="T" else "T" if b=="A" else "C" if b=="G" else "G")

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

Solution (Python):
s = input()

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

Solution (Python):
b = input()

c = ""

for d in b:
    if d=="A":
        c = c + "T"
    elif d=="C":
        c = c + "G"
    elif d=="G":
        c = c + "C"
    else:
        c = c + "A"
    
print(c)

Solution (Python):
c=input()
if c=='A':
  print('T')
elif c=='T':
  print('A')
elif c=='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")
else:
    print("C")

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

Solution (Python):
a=input()
if a=="A":
  print("T")
elif a=="C":
  print("G")
elif a=="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")
else:
    print("C")

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

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):
s = input()
if s == "A":print("T")
elif s == "C":print("G")
elif s == "G":print("C")
else:print("A")

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

Solution (Python):
enki_dict={"A":"T","C":"G","T":"A","G":"C"}
b = input()
ans = enki_dict[b]
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()
d = dict(
    A='T', T='A', G='C', C='G' 
)
print(d[b])

Solution (Python):
import os, sys, re, math

(b) = input()

print('TGCA'['ACGT'.find(b)])

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

Solution (Python):
data=["A","C","T","G","A","C"]
b=input()
for i in range(4):
    if data[i]==b:
        print(data[i+2])
        break

Solution (Python):
a = 'ATCG'
b = 'TAGC'
x = input()
for i in range(0, 4):
  if x[0] == a[i]:
    print(b[i])

Solution (Python):
b = input()
i = ['A','C','G','T']
o = ['T','G','C','A']
print(o[i.index(b)])

Solution (Python):
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7


b = sys.stdin.buffer.readline().decode().rstrip()
if b == 'A':
    print('T')
if b == 'T':
    print('A')
if b == 'C':
    print('G')
if b == 'G':
    print('C')

Solution (Python):
N = input()
if(N=='A'):
	print('T',end="")
if(N=='C'):
	print('G',end="")
if(N=='G'):
	print('C',end="")
if(N=='T'):
	print('A',end="")

Solution (Python):
b = input()

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

Solution (Python):
s=str(input())
if(s=="A"):
  print("T")
elif(s=="C"):
  print("G")
elif(s=="G"):
  print("C")
elif(s=="T"):
  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')
else:
    pass

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

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

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


if __name__ == '__main__':
    solve()

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":
    ans = "T"
elif b == "T":
    ans = "A"
elif b == "C":
    ans = "G"
else:
    ans = "C"

print(ans)

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=='A':
  print('T')
elif b=='T':
  print('A')
elif b=='C':
  print('G')
else:
  print('C')

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

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

Solution (Python):
import math

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

Solution (Python):
s = input()
if s == 'A':
    print('T')
elif s == 'T':
    print('A')
elif s == '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')
else:
  print('C')

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

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

else:
    print('G')

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

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

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=="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 = input()
print('A' if b == 'T' else 'T' if b == 'A' else 'C' if b == 'G' else 'G')

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

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

Solution (Python):
a=input()
if a=="A":
  print("T")
if a=="T":
  print("A")
if a=="G":
  print("C")
if a=="C":
  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=="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()
dic={"A":"T","C":"G","G":"C","T":"A"}
print(dic[b])

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

Solution (Python):
a=input()
if a=='A':
  print('T')
if a=='T':
  print('A')
if a=='C':
  print('G')
if a=='G':
  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):
s=input()
if s=="A":
  print("T")
elif s=="T":
  print("A")
elif s=="G":
  print("C")
elif s=="C":
  print("G")

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

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

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

if( 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):
s = input()
if s == 'A':
  print('T')
elif s ==  'T':
  print('A')
elif s ==  'C':
  print('G')
elif s ==  'G':
  print('C')

Solution (Python):
b = input()
enki = ["A", "C", "G", "T"]
if b == enki[0]:
    print("T")
elif b == enki[1]:
    print("G")
elif b == enki[2]:
    print("C")
else:
    print("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):
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 in "AT":
    s = "AT".index(b)
    print("AT"[s - 1])
else:
    s = "GC".index(b)
    print("GC"[s - 1])

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

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

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

Solution (Python):
b=input()
if b==str("A"):
  print("T")
elif b==str("C"):
  print("G")
elif b==str("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")
else:
    print("G")

Solution (Python):
import sys, os
import collections

def solve(input_stream):
  table = {
    "A": "T",
    "T": "A",
    "C": "G",
    "G": "C"
  }
  ans = ""
  for i in input_stream.readline().strip():
    ans += table[i]
  return [ans]

if __name__ == "__main__":
    outputs = solve(sys.stdin)
    for line in outputs:
      print(line)

Solution (Python):
b = input()

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

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):
s = input()
print('A' if s == 'T' else 'T' if s == 'A' else 'C' if s == '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()

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

print(enki[b])

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")
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=="C":
    print("G")
else:
    print("C")

Solution (Python):
b = input()

d = {"A": "T", "T": "A", "C": "G", "G": "C"}
print(d.get(b))

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

p_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()
d = {"A":"T", "C":"G", "G":"C", "T":"A"}
print(d[b])

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