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

Solution (Python):
a = str(input())
b = "A"
c = "C"
d = "G"
e = "T"

if a == c:
  print("G")
if a == b:
  print("T")
if a == d:
  print("C")
if a == e:
  print("A")

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

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

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

Solution (Python):
b = input()

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


if __name__ == "__main__":
    main()

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

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

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):
l1 = ['A','T']
l2 = ['C','G']
b = str(input())
ans = ''
if b in l1:
    l1.remove(b)
    ans = l1[0]
if b in l2:
    l2.remove(b)
    ans = l2[0]
print(ans)

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

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

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

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

else:
    print('A')

Solution (Python):
s = 'ATCG'
b = input()

ans = 0
for i in range(4):
    if b == s[i]:
        ans = i^1
print(s[ans])

Solution (Python):
print('ATCG'['ATCG'.index(input()) ^ 1])

Solution (Python):



get = lambda: int(raw_input().strip())
gets = lambda: [int(i) for i in raw_input().strip().split()]
getss = lambda n: [gets() for _ in xrange(n)]


C = raw_input().strip()
m = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A'}
print m[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=str(input())
 
if a=="A":
    print("T")
if a=="T":
    print("A")
if a=="G":
    print("C")
if a=="C":
    print("G")

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

Solution (Python):
S = input()
D = {'A':'T', 'T':'A', 'C':'G', 'G':'C'}
print(D[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):
def main():
    a = input()
    dict = {'A':'T', 'T':'A', 'G':'C', 'C':'G'}
    print(dict[a])

if __name__ == '__main__':
    main()

Solution (Python):
s=input()

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

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

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

Solution (Python):
B = input()

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

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

print(dna[input()])

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

b=str(input())
print(dna[b])

Solution (Python):
b = input()
ans =""

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

print(ans)

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

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

Solution (Python):
enki = input()
enkis = ['A','C','G','T']
twin = ['T','G','C','A']
print(twin[enkis.index(enki)])

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


s = input()
print(ans[s])

Solution (Python):

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

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

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

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

print(a[input])

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

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

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

Solution (Python):
b = input()

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

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

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

Solution (Python):
at = "AT"
cg = "CG"
b = input()
if b in at:
    print(at[(at.index(b) + 1) % 2])
else:
    print(cg[(cg.index(b) + 1) % 2])

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

Solution (Python):
a = raw_input()
if a=='A':
  print 'T'
elif a=='T':
  print 'A'
elif a=='G':
  print 'C'
else:
  print 'G'

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

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()

def main():
    b = SI()
    dic = dict(zip('AGCT', 'AGCT'[::-1]))
    ans = dic[b]

    return ans

print(main())

Solution (Python):
print({"A": "T", "T": "A", "C": "G", "G": "C"}[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):
print(input().translate(str.maketrans('ATCG', 'TAGC')))

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

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

Solution (Python):
b = input()
if b in "AT":
  print("AT".replace(b, ""))
else:
  print("GC".replace(b, ""))

Solution (Python):
x = input()

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

Solution (Python):


b = input()

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

print(data[b])

Solution (Python):
print('TCG鬱A'[ord(input())%5])

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

Solution (Python):
s='ACGT';print(s[3-s.index(input())])

Solution (Python):
if __name__ == '__main__':
  V = input()
  
  if V == "T":
  	print("A")
  
  if V == "A":
    print("T")
  
  if V == "C":
    print("G")
  
  if V == "G":
    print("C")

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

print(test[input()])

Solution (Python):
c=input()
print("ATGC"[(c=="A")+(c=="G")*3+(c=="C")*2])

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 = str(input())
char = 'AGCT'
index = char.index(b)
print(char[::-1][index])

Solution (Python):
base = 'ATAGCG'
print(base[base.index(input())+1])

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

Solution (Python):
inverse = {'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G'}
print(inverse[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):
import sys

input = sys.stdin.readline
b = input()
if b[0] == 'A':
    print('T')
elif b[0] == 'T':
    print('A')
elif b[0] == 'C':
    print('G')
else:
    print('C')

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

Solution (Python):
print('TGCA'['ACGT'.index(input())])

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

Solution (Python):
print('TCG A'[ord(input())%5])

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

Solution (Python):
s = input()
lis = ["A", "T", "G", "C"]
lis2 = ["T", "A", "C", "G"]
print(lis2[lis.index(s)])

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

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):
lis = ["A","T","G","C"]
li = ["T","A","C","G"]
s = str(input())
print(li[lis.index(s)])

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

Solution (Python):
def change(x):
	if x == 'A':
		return 'T'
	elif x == 'T':
		return 'A'
	elif x == 'C':
		return 'G'
	elif x == 'G':
		return 'C'
	return None

print(''.join([change(x) for x in input()]))

Solution (Python):
def change(x):
	if x == 'A':
		return 'T'
	elif x == 'T':
		return 'A'
	elif x == 'C':
		return 'G'
	elif x == 'G':
		return 'C'
	return None

print(''.join([change(x) for x in input()]))

Solution (Python):
n=input();a="ACGT";print(a[a.index(n)^3])

Solution (Python):
n = input();ans="ACGT";k=ans.index(n)^3;print(ans[k])

Solution (Python):
print('TA  CG'[(66-ord(input()))//4])

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

Solution (Python):
tmp = input()

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

Solution (Python):
a = input()
if a is 'A' :
	print('T')
elif a is 'T' :
	print('A')
elif a is '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):
print('TGC   A'[(ord(input())-64)//3])

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

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

Solution (Python):
s = "ATCG"
k = s.index(input())
print(s[k ^ 1])

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

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

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

Solution (Python):
str = input()

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

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

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

}
s = input().rstrip()
print(ans[s])

Solution (Python):




def solveProblem(inputString):
	answer = ""
	if inputString == "A":
		answer = "T"
	elif inputString == "T":
		answer = "A"
	elif inputString == "C":
		answer = "G"
	elif inputString == "G":
		answer = "C"
	else :
		answer = ""
	return answer


if __name__ == '__main__':
	b = str(input().strip())
	solution = solveProblem(b)
	print("{}".format(solution))

Solution (Python):
import sys
import numpy as np
sys.setrecursionlimit(20000000)
input = sys.stdin.readline
s = input()
s = s[0]
if s == "A":
        print("T")
if s == "T":
        print("A")
if s == "G":
        print("C")
if s == "C":
        print("G")

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

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

Solution (Python):


what = input()

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

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

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

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

Solution (Python):
a = "ACGT"
print(a[3-a.index(input())])

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

Solution (Python):
c = input()

arr = [['A', 'T'], ['G', 'C']]

if c in arr[0]:
    index = arr[0].index(c)
    print(arr[0][(index+1)%2])
elif c in arr[1]:
    index = arr[1].index(c)
    print(arr[1][(index+1)%2])

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

print(ans)

Solution (Python):

line = input()
list = ["A","T","G","C"]
if line == list[0]:
    print(list[1])
elif line == list[1]:
    print(list[0])
elif line == list[2]:
    print(list[3])
else:
    print(list[2])

Solution (Python):
S = ' ACGT'
print(S[-1*S.index(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','T':'A','C':'G','G':'C'}[raw_input()])

Solution (Python):


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

Solution (Python):



b = input()

if b == "A":
    out = "T"
if b == "T":
    out = "A"
if b == "G":
    out = "C"
if b == "C":
    out = "G"

print(out)

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):
i = input();

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

Solution (Python):


import sys

def parse_input(lines_as_string = None):


    lines = []
    if lines_as_string is None:
        lines.append(input())
    else:
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    tokens = lines[0].split(" ")
    b = tokens[0]

    return (b,)


def solve(b):
    
    m = {
        "A": "T",
        "C": "G",
        "G": "C",
        "T": "A",
    }

    return m[b]

def main():
    

    print("%s" % solve(*parse_input()))

if __name__ == '__main__':

    main()

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

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

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

Solution (Python):


x = input()

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

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

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

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

Solution (Python):

import sys



def solve(lines):
    S = lines.pop(0)
    if S == 'A':
        print('T')
    elif S == 'T':
        print('A')
    elif S == 'C':
        print('G')
    elif S == 'G':
        print('C')

lines = [x.strip() for x in sys.stdin.readlines()]




solve(lines)

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" or b == "T":
    if b == "A":
        print("T")
    else:
        print("A")

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

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

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

print(ans)

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

Solution (Python):
def helix(c):
    helixs = {"A": "T", "C": "G","T": "A","G": "C"}
    return helixs[c]

c = input()
print(helix(c))

Solution (Python):
data = input().upper()

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

while ans == "A" or "T" or "C" or "G":

    
    if ans == "A":
        print("T")
        break

    elif ans == "T":
        print("A")
        break

    elif ans == "C":
        print("G")
        break

    elif ans == "G":
        print("C")
        break

    
    ans = input()

Solution (Python):
enki = input()

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

Solution (Python):
b = input()
at = ["A", "T"]
cg = ["C", "G"]

if b in at:
    at.remove(b)
    print(at[0])

if b in cg:
    cg.remove(b)
    print(cg[0])

Solution (Python):
import sys
from operator import itemgetter
import collections


def r(s):
    if s == 'A':
        return 'T'
    elif s == 'T':
        return 'A'
    elif s == 'G':
        return 'C'
    elif s == 'C':
        return 'G'


def main():
    input = sys.stdin.readline
    s = str(input()).strip()

    print(r(s))


if __name__ == '__main__':
    main()

Solution (Python):
x = input()

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

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):
print('ATCG'['TAGC'.index(input())])

Solution (Python):
tmp = input()
a = "A"
c = "C"
g = "G"
t = "T"

if tmp == a:
  print(t)
elif tmp == c:
  print(g)
elif tmp == t:
  print(a)
else:
  print(c)

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

print(ans)

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

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

Solution (Python):
a=input()

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

print(d[a])

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

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

elif b == 'T':

    print('A')

elif b == 'G':

    print('C')

else:

    print('G')

Solution (Python):
from sys import stdin

b = stdin.readline().rstrip()

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

Solution (Python):
from sys import stdin

a = stdin.readline().rstrip()

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

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

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

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

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

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

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

print(pair[input().strip()])

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

def C(b):
    return dic[b]

a=input()
print(C(a))

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

Solution (Python):
b = input()

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

Solution (Python):
a = input()

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

Solution (Python):

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

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

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

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

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

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

Solution (Python):
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):
L = input()

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

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

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

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

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

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

Solution (Python):
print "ATGC"["TACG".index(raw_input())]

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')
elif b == 'C':
    print('G')
else:
    print(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):
base = input()
candidate = ["A","T","C","G",""]
index_num = candidate.index(base)
print([candidate[index_num-1],candidate[index_num+1]][candidate.index(base)%2==0])

Solution (Python):
b = input()
s = ""
for i in range(len(b)):
    if b[i] == "A":
        s += "T"
    elif b[i] == "T":
        s += "A"
    elif b[i] == "C":
        s += "G"
    else:
        s += "C"
print(s)

Solution (Python):
one = "AT"
two = "CG"
b = input()
if b in one:
    print(one.replace(b, ""))
else:
    print(two.replace(b, ""))

Solution (Python):


import sys

def parse_input(lines_as_string = None):


    lines = []
    if lines_as_string is None:
        lines.append(input())
    else:
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    tokens = lines[0].split(" ")
    b = tokens[0]

    return (b,)


def solve(b):
    
    m = {
        "A": "T",
        "C": "G",
        "G": "C",
        "T": "A",
    }

    return m[b]

def main():
    

    print("%s" % solve(*parse_input()))

if __name__ == '__main__':

    main()

Solution (Python):
print "ATGC"["TACG".index(raw_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):
n = str(input()) 
if n == ("A"):
    print("T")
elif n == ("T"):
    print("A")
elif n == ("G"):
    print("C")
else:
    print("G")

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

print(helix[input()])

Solution (Python):
b = input()
l = ["A", "C", "G", "T"]
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')
else:
  print('C')

Solution (Python):
B = input()
L1 = "ACGT"
L2 = "TGCA"
print(L2[L1.index(B)])