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

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

Solution (Python):
bmap = {'A':'T', 'T':'A', 'G':'C', 'C':'G'}
print(bmap[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):
icase=0
if icase==0:
    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):
print({"A":"T","T":"A","G":"C","C":"G"}[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):
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':
  s='T'
elif b=='T':
  s='A'
elif b=='G':
  s='C'
else:
  s='G'
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):
import math
import collections
import sys


def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]

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

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

Solution (Python):
b = input()

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

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

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

Solution (Python):
im = input()

if (im == 'A'):
    ans = 'T'
elif (im == 'T'):
    ans = 'A'
elif (im == 'C'):
    ans = 'G'
else:
    ans = 'C'

print(ans)

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

Solution (Python):

import sys
input = sys.stdin.readline









B = input().rstrip()
d = {
    "A":"T",
    "T":"A",
    "C":"G",
    "G":"C"
}
print(d[B])

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

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

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

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

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

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

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

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

Solution (Python):
import numpy as np
import sys
readline = sys.stdin.readline
read = sys.stdin.read

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

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

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

Solution (Python):













b = input()

AT = set(["A","T"])
CG = set(["C","G"])
if b in AT:
    ans = AT - set(b)
else:
    ans = CG -set(b)

print(ans.pop())

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

print(b)

Solution (Python):
b = input()

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

print(b)

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

Solution (Python):
b=input()

enki={"A":"T","T":"A","G":"C","C":"G"}
ans=""
for i in b:
    ans+=enki[i]
print(ans)

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

Solution (Python):
b = input()
i = list('TGCA')
j = list('ACGT')
print(i[j.index(b)])

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

print(b)

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()
input_nums = lambda: list(map(int, input().split()))

def main():
    b = input()
    at = ('A', 'T')
    cg = ('C', 'G')
    revAT = lambda x: at[0] if x != 'A' else at[1]
    revCG = lambda x: cg[0] if x != 'C' else cg[1]
    if b == 'A' or b == 'T': print(revAT(b))
    else: print(revCG(b))

if __name__ == '__main__':
    main()

Solution (Python):
s = "ACTG"
print(s[s.index(input())-2])

Solution (Python):
b = input()
s = list("ACTG")

print(s[(s.index(b)+2)%4])

Solution (Python):









b = input()
c = []
for i in range(len(b)):
  if b[i] == 'A':
    c.append('T')
  elif b[i] == 'T':
    c.append('A')
  elif b[i] == 'G':
    c.append('C')
  else:
    c.append('G')
print(''.join(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 == '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()
d={"A":"T","C":"G","G":"C","T":"A"}
print(d[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):


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

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

Solution (Python):
b=input()
lis=["A","G","T","C"]
print(lis[(int(lis.index(b))+2)%4])

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

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

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

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

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

Solution (Python):
b = input()

if b=='A':
  print('T')
  
elif b=='G':
  print('C')
  
elif b=='T':
  print('A')
elif 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):
import sys
input = lambda: sys.stdin.readline().rstrip()

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

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

Solution (Python):
from collections import deque
from collections import Counter
from itertools import product, permutations,combinations
from operator import itemgetter
from heapq import heappop, heappush
from bisect import bisect_left, bisect_right, bisect




from fractions import gcd
from math import ceil,floor, sqrt, cos, sin, pi, factorial
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**8)
INF = float('inf')

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

Solution (Python):
b = input()

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

Solution (Python):
a = input()
if a == "A":
    print("T")
elif a == "T":
    print("A")
elif a == "G":
    print("C")
elif a == "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):
import itertools
import fractions
def main():
  b = input()
  if b == 'A':
    print('T')
  elif b == 'T':
    print('A')
  elif b == 'G':
    print('C')
  elif b == 'C':
    print('G')
if __name__ == '__main__':
  main()

Solution (Python):
b = input()

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

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

list={"A":"T","T":"A","G":"C","C":"G"}
b = input().strip()
print(list[b])

Solution (Python):



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

Solution (Python):
import sys

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

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

def main():
    print(pair[b])

if __name__ ==  '__main__':
    main()

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

Solution (Python):
b = input()

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

print(d[b])

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

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

if __name__ == '__main__':
    resolve()

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

Solution (Python):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

if __name__ == '__main__':
    a =input()

    if a =="A":
        print("T")
    if a == "C":
        print("G")
    if a == "T":
        print("A")
    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()
l = ['A','C','G','T']
rev = ['T','G','C','A']
print(rev[l.index(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=input()

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

Solution (Python):
b = input()
dic = {"A": "T", "C": "G"}
if b in dic:
    print(dic[b])
else:
    print(*[k for k, v in dic.items() if v == b])

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

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

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):
def main():
  
  s = input()
  
  
  
  
  
  
  ans = 0
  count = 0
  lis = []
  
  if s == "A" or s == "T":
    print("AT".replace(s,""))
  else:
    print("CG".replace(s,""))
    

if __name__ == '__main__':
  main()

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

Solution (Python):
import sys
from bisect import *
from heapq import *
from collections import *
from itertools import *
from functools import *
from math import *
from fractions import *

sys.setrecursionlimit(100000000)
input = lambda: sys.stdin.readline().rstrip()

def f(c):
    if c == 'A': return 'T'
    if c == 'T': return 'A'
    if c == 'C': return 'G'
    if c == 'G': return 'C'

print(''.join(map(f, 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")
elif b == "G":
    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')
elif b == 'G':
    print('C')

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

if b=='A' or b=='T':
    l.remove(b)
    print(l[0])
if b=='C' or b=='G':
    m.remove(b)
    print(m[0])

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

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

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

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

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

Solution (Python):
import sys
import os

MOD = 10 ** 9 + 7


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

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


if __name__ == '__main__':
    main()

Solution (Python):
b = input()

if b == "A" :
	answer = "T"

if b == "C" :
	answer = "G"

if b == "G" :
	answer = "C"

if b == "T" :
	answer = "A"

print(answer)

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

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

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

main()

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

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

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

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

Solution (Python):


def main():
    b = input()

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

    print(pairs[b])

if __name__ == '__main__':
    main()

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

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

Solution (Python):
x = input()

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

Solution (Python):
b=input()
A="AT"
B="CG"
if b in A:
    ans=A.replace(b,"")
else:
    ans=B.replace(b,"")
print(ans)

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

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

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

Solution (Python):
b = list(input())
ans = [None]*len(b)
def en(n):
    if n == "A":
        return "T"
    elif n == "T":
        return "A"
    elif n == "G":
        return "C"
    else:
        return "G"
for i in range(len(b)):
    ans[i] = en(b[i])
print(*ans)

Solution (Python):
s = input()
verse = "ACGT"
inverse = "TGCA"
id = verse.index(s)
print(inverse[id])

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 accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
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()

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

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

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

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

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


if __name__ == "__main__":
    main()

Solution (Python):
S=input()

a=["A","T","C","G"]
b=["T","A","G","C"]

print(b[a.index(S)])

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

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

Solution (Python):

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

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

Solution (Python):

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

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

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

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

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

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

Solution (Python):
b = input()

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

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

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

Solution (Python):
clb=['A','T','G','C']
K=input()
if clb[0]==K or clb[2]==K:
    print(clb[clb.index(K)+1])
else:
    print(clb[clb.index(K)-1])

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

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

Solution (Python):

import sys


def solve(b: str):
    S = '
    return S[-S.find(b)]



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    b = next(tokens)  
    print(solve(b))

if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
s=str(input())
l=[]
for i in range(len(s)):
  if s[i]=='A':
    l.append('T')
  if s[i]=='T':
    l.append('A')
  if s[i]=='G':
    l.append('C')
  if s[i]=='C':
    l.append('G')
print(''.join(l))

Solution (Python):
b = input()
at = ['A', 'T']
cg = ['C', 'G']
if b in at:
    at.remove(b)
    print(at[0])
else:
    cg.remove(b)
    print(cg[0])

Solution (Python):
b = input()

big = ["A","T","G","C"]
cou = ["T","A","C","G"]

ans = cou[big.index(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):
d = {
  'A': 'T',
  'T': 'A',
  'C': 'G',
  'G': 'C'
}

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()
dic={i:j for i,j in zip('ATCG','TAGC')}
print(dic[b])

Solution (Python):



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

Solution (Python):
b = input()
d = dict(zip("ACTG", "TGAC"))
print(d[b])

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

    print(d[b])


if __name__ == "__main__":
    main()

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

Solution (Python):
s = input()
at = {"A", "T"}
cg = {"C", "G"}

if s in at:
    print((at - set(s)).pop())
if s in cg:
    print((cg - set(s)).pop())

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

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

print(S[N])

Solution (Python):


b = input().strip()

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

Solution (Python):

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

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

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

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

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

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

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