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

result = {
    "A": "T",
    "T": "A",
    "C": "G",
    "G": "C",
}[b]

print(result)

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

Solution (Python):
enki = input()

if enki in 'AT':
  print('AT'.replace(enki, ''))
else:
  print('CG'.replace(enki, ''))

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

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

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

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

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

Solution (Python):
s = str(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 == 'G':
    print('C')
elif b == 'C':
    print('G')

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

Solution (Python):

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

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

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

resolve()

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

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

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

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):
def solve(string):
    return string.replace("A", "B").replace("T", "A").replace("B", "T").replace("C", "B").replace(
        "G", "C").replace("B", "G")


if __name__ == '__main__':
    print(solve(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):
a=input()

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

Solution (Python):
n = input()
table = n.maketrans('A T C G','T A G C')
print(n.translate(table))

Solution (Python):
import sys

input = sys.stdin.readline

b = input().rstrip()

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

for i, x in enumerate(lis):
    if (b == x):
        print(lis[i-2])

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

b = input()

at = ["A", "T"]
gc = ["G", "C"]

if b == "A" or b == "T":
	at.remove(b)
	print(at.pop())
else:
	gc.remove(b)
	print(gc.pop())

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

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

Solution (Python):
T='ATCG'
print(T[T.find(input())^1])

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

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

Solution (Python):

from sys import stdin

list = { "A":"T", "C":"G", "T":"A", "G":"C" }
print(list[stdin.readline().rstrip()])

Solution (Python):
from sys import stdin
b = stdin.readline().rstrip()

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

Solution (Python):


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

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

Solution (Python):
import sys

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

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


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

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

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

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

Solution (Python):
b = input()

d = {}
d["A"] = "T"
d["T"] = "A"
d["G"] = "C"
d["C"] = "G"

print(d[b])

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

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

Solution (Python):
a='ATCG'
print(a['TAGC'.index(input())])

Solution (Python):
def main():
    b = input()
    argc = len(b)
    data = []
    for i in range(argc):

      if (b[i]=='A'):
        data.append('T')
      elif (b[i]=='T'):
        data.append('A')
      elif (b[i]=='C'):
        data.append('G')
      else:
        data.append('C')
    result = ''.join(data)
    print(result)
main()

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

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

Solution (Python):


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

print(data[input()])

Solution (Python):
if __name__ == "__main__":
    first = {'A','T'}
    second = {'C','G'}

    N = input()

    for x in [first,second]:
        if len(x - {N}) == 1:
            print(list(x-{N})[0])

Solution (Python):
s = "ACGT"
b = input()
print(s[3 - s.find(b)])

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

Solution (Python):
input = input()

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

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

Solution (Python):


s = input()

a1 = ['A','T']
a2 = ['C','G']

if s in a1:
    l = a1
else:
    l = a2

t = l.pop(l.index(s))
print(l[0])

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

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

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

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

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

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

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

print(d[input()])

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

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

Solution (Python):
z =input()

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

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

Solution (Python):
lst = ["A","C","G","T"]
pair = ["T","G","C","A"]

print(pair[lst.index(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):
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):
a = input()
if a == 'A':
  print('T')
elif a == 'C':
  print('G')
elif a == 'G':
  print('C')
elif a == 'T':
  print('A')

Solution (Python):
S=input()

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

Solution (Python):
"""
A - Double Helix
https://atcoder.jp/contests/abc122/tasks/abc122_a
"""
if __name__ == '__main__':
    input = str(input())
    if input == 'A':
        print("T")
    if input == 'T':
        print("A")
    if input == 'C':
        print("G")
    if input == 'G':
        print("C")

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

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

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

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

Solution (Python):
a = input()
t = str.maketrans('ACGT', 'TGCA')
print(a.translate(t))

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

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

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

Solution (Python):



bases_dict = {'A' : 'T', 'T' : 'A', 'C' : 'G', 'G' : 'C'}
base = raw_input()

print '{}'.format(bases_dict[base])

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

Solution (Python):
b = str(input())
enki = {"A":"T", "T":"A", "G":"C", "C":"G"}
print(enki[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 = str(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):
def trans(g):
    gene = ['A', 'G', 'T', 'C']
    return gene[(gene.index(g)+2)%4]

b = input()
ans = ''

for i in b:
    ans += trans(i)

print(ans)

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

Solution (Python):
n = input()

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

print(Ans)

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

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


a = str(input())

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

print(x[a])

Solution (Python):
b = input()

if b == 'A':
    output = 'T'
elif b == 'C':
    output = 'G'
elif b == 'G':
    output = 'C'
elif b == 'T':
    output = 'A'
else:
    pass

print(output)

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

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

print(words[X])

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

Solution (Python):

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

Solution (Python):
import sys

def i2s():
    return sys.stdin.readline().rstrip()

def ii2ss(n):
    return [sys.stdin.readline() for _ in range(n)]

def sp2nn(sp, sep=' '):
    return [int(s) for s in sp.split(sep)]

def ss2nn(ss):
    return [int(s) for s in list(ss)]

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

main(i2s())

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

Solution (Python):
b = input()

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

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

Solution (Python):
s = input()
l_1 = ['A', 'T']
l_2 = ['C', 'G']
if s in l_1:
  l_1.remove(s)
  print(l_1[0])
else:
  l_2.remove(s)
  print(l_2[0])

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

Solution (Python):



def main():
    S = raw_input()
    ans = ''
    if S == 'A':
        ans = 'T'
    elif S == 'T':
        ans = 'A'
    elif S == 'C':
        ans = 'G'
    elif S == 'G':
        ans = 'C'
    return ans
print(main())

Solution (Python):
ref=input()

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

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

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

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

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

s = input().strip()
print(mapping[s])

Solution (Python):
print(input().translate(str.maketrans('ATGC', 'TACG')))

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

Solution (Python):
import sys

arg = input()

if arg=='A':
    arg='T'
elif arg=='T':
    arg='A'
if arg=='C':
    arg='G'
elif arg=='G':
    arg='C'

print(arg)

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

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

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

}

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

Solution (Python):
code= input()
def function(code):
  if code =="A":
    return 'T'
  elif code == "T":
    return "A"
  elif code == "G":
    return "C"
  elif code == "C":
    return "G"
  
print(function(code))

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

Solution (Python):
b=input(str())
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')
else:
    print('G')

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

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

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

Solution (Python):


l = (("A","T"),("G","C"))
i = input()
if i in l[0]:
    if i == l[0][0]:
        print(l[0][1])
    else: print(l[0][0])
else:
    if i == l[1][0]:
        print(l[1][1])
    else: print(l[1][0])

Solution (Python):
b = input()

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

print(OUT)

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

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

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

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

print(ans)

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

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

Solution (Python):
i = input();print("AT"[i=="A"]) if i in list("AT") else print("GC"[i=="G"])

Solution (Python):
i = input();print("AT"[i=="A"]) if i in list("AT") else print("GC"[i=="G"])

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

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

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

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

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

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

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

Solution (Python):
n=input()

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

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

Solution (Python):
print("TGCA"[int(input().replace('A','0').replace('C','1').replace('G','2').replace('T','3'))])

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

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

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

Solution (Python):
def foo(s):
    if s == 'A':
        return 'T'
    elif s == 'C':
        return 'G'
    elif s == 'G':
        return 'C'
    elif s == 'T':
        return 'A'

s = input()
print(foo(s))

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

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

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

Solution (Python):
base = input()


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

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






input = input()

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

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

else:
	print("A")