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

Solution (Python):
b = input()

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

if str=="A":
    print ("T")
    exit()

if str =="T":
    print ("A")
    exit()

if str =="G":
    print ("C")
    exit()

if str =="C":
    print ("G")
    exit()

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):
N = str(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()
s = ""
for c in b:
    if c == "A":
        s += "T"
    elif c == "T":
        s += "A"
    elif c == "C":
        s += "G"
    elif c == "G":
        s += "C"

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

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

Solution (Python):
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque, OrderedDict
from copy import deepcopy
from functools import lru_cache, reduce
from math import ceil, floor
from sys import setrecursionlimit

import heapq
import itertools
import operator


inf = float('inf')


def get_int():
    return int(input())


def get_float():
    return float(input())


def get_str():
    return input().strip()


def get_li():
    return [int(i) for i in input().split()]


def get_lf():
    return [float(f) for f in input().split()]


def get_lc():
    return list(input().strip())


def get_data(n, types):
    if len(types) == 1:
        return [types[0](input()) for _ in range(n)]
    return zip(*(
        [t(x) for t, x in zip(types, input().split())]
        for _ in range(n)
    ))



B = ""


def set_inputs():
    global B
    B = get_str()
    return


def main():
    setrecursionlimit(100000)
    set_inputs()
    d = {"A": "T", "C": "G", "G": "C", "T": "A"}
    print(d[B])
    return


if __name__ == '__main__':
    main()

Solution (Python):
b = input()

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

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

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

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 sys

l = raw_input().split()
b = l[0]

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

print(table[b])

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

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

Solution (Python):
from sys import stdin
b = stdin.readline().rstrip()
if b == 'A':
    print('T')
elif b == 'T':
    print('A')
elif b == 'C':
    print('G')
elif b == 'G':
    print('C')

Solution (Python):
B=raw_input()

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

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

Solution (Python):
b = input()

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

Solution (Python):
def double_helix(b: str)->str:
    if b == 'A':
        return 'T'
    if b == 'T':
        return 'A'
    if b == 'C':
        return 'G'
    return 'C'


if __name__ == "__main__":
    b = input()
    ans = double_helix(b)
    print(ans)

Solution (Python):
b = input()

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

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

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

Solution (Python):
s = input()

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

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

Solution (Python):
b = input()

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

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

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

Solution (Python):

"""
Created on Sat Feb 16 20:52:46 2019

@author: Owner
"""


import collections
import scipy.misc
import sys
import numpy as np
import math
from operator import itemgetter
import itertools
import copy
import bisect


def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(int(i))
    i += 1
  if n > 1:
    table.append(int(n))
  return table   

def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []
    
def getNearestValueIndex(list, num):
    """
    概要: リストからある値に最も近い値のインデックスを取得する関数
    @param list: データ配列
    @param num: 対象値
    @return 対象値に最も近い値
    """

    
    idx = np.abs(np.asarray(list) - num).argmin()
    return idx

def find_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default


"""
N, X = map(int, input().split())

x = [0]*N
x[:] = map(int, input().split())

P = [0]*N
Y = [0]*N
for n in range(N):
    P[n], Y[n] = map(int, input().split())

    
all(nstr.count(c) for c in '753')


ABT = zip(A, B, totAB)
result = 0

sorted(ABT,key=itemgetter(2))
A, B, totAB = zip(*ABT)
A.sort(reverse=True)


(x >> i) & 1


dp = [np.inf]*N
for n in range(N):
    if n == 0:
        dp[n] = 0
    else:
        for k in range(1,K+1):
            if n-k >= 0:
                dp[n] = min(dp[n], dp[n-k] + abs(h[n]-h[n-k]))
            else:
                break

"""

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

Solution (Python):
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=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()
dic = {"A":"T", "C":"G", "G":"C", "T":"A"}

print(dic[b])

Solution (Python):
b = input()

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

Solution (Python):
import sys
 
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()

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






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

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

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


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

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

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

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

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

Solution (Python):

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

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

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


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

Solution (Python):

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

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

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

Solution (Python):
b = input()

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

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

print(dna[b])

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

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

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

Solution (Python):
inp = input()

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

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

ret = ''
if s == 'A':
  ret = 'T'
elif s == 'T':
  ret = 'A'
elif s == 'C':
  ret = 'G'
elif s == 'G':
  ret = 'C'

print(ret)

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

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

Solution (Python):
b = input()
ans = ""
for s in b:
    if s == 'A':
        ans += 'T'
    elif s == 'T':
        ans += 'A'
    elif s == 'C':
        ans += 'G'
    else:
        ans += 'C'
print(ans)

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

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

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

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

Solution (Python):
def solve(b):
    if b == "A":
        return "T"
    if b == "T":
        return "A"
    if b == "G":
        return "C"
    if b == "C":
        return "G"


b = input()
print(solve(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 = str(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()

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

print(ans[b])

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

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

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

Solution (Python):
b = input()
ans = ""
for i in range(1):
  if b[i] == 'A': ans  += 'T'
  elif b[i] == 'T': ans  += 'A'
  elif b[i] == 'C': ans  += 'G'
  elif b[i] == 'G': ans  += 'C'
print(ans)

Solution (Python):

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

Solution (Python):




b = input()


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


print(ans)

Solution (Python):
b = input()

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

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

Solution (Python):
b = input()

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

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

from collections import deque
def inpl(): return list(map(int, input().split()))

S = input()
A = list("ATCG")
B = list("TAGC")

print(B[A.index(S)])

Solution (Python):

import sys


def solve(b: str):
    if(b == 'A'):
        print('T')
    elif(b == 'C'):
        print('G')
    elif(b == 'G'):
        print('C')
    elif(b == 'T'):
        print('A')
    return



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

if __name__ == '__main__':
    main()

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

print(_dict[b])

Solution (Python):
b = input()

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

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

Solution (Python):
b = input()

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

Solution (Python):
b = input()

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

Solution (Python):
b = input()

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

Solution (Python):


b = input()
ret = ""

if b == "A":
    ret = "T"
elif b == "T":
    ret = "A"
elif b == "C":
    ret = "G"
elif b == "G":
    ret = "C"

print(ret)

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

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

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

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

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

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

print(m[input()])

Solution (Python):
from sys import exit

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
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())



b = input().rstrip()

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

print(ans)

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

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

print(d[b])

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

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

import heapq
import re
import bisect
import random
import math
import itertools
from collections import defaultdict, deque
from copy import deepcopy
from decimal import *

n = input()

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

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

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 == '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):
def int_raw():
    return int(raw_input())

def ss_raw():
    return raw_input().split()

def ints_raw():
    return map(int,ss_raw())

INF = 1<<29

def make1d_arr(n,val=INF):
    return [val for i in xrange(n)]

def make2d_arr(w,h,val =INF):
    return [[val for i in xrange(w)]for i in xrange(h)]

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

chars = []
for ch in s:
    if ch == "A":
        chars.append("T")
    elif ch == "T":
        chars.append("A")
    elif ch == "G":
        chars.append("C")
    elif ch == "C":
        chars.append("G")
print("".join(chars))

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

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

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

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

Solution (Python):
b = input()


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

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

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

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

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

    return ans

print(main())

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

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

Solution (Python):
b = input()
ans = ''
for s in 'AT', 'CG':
    if b in s:
        ans = s.replace(b, '')
        break
print(ans)

Solution (Python):
import io, sys, atexit, os

import math as ma
from sys import exit
from decimal import Decimal as dec
from itertools import permutations


def li ():
	return list (map (int, input ().split ()))


def num ():
	return map (int, input ().split ())


def nu ():
	return int (input ())


def find_gcd ( x, y ):
	while (y):
		x, y = y, x % y
	return x


mm = 1000000007



def solve ():
	t = 1
	for it in range (t):
		b=input()
		if(b=="A"):
			print("T")
		if(b=="T"):
			print("A")
		if(b=="C"):
			print("G")
		if(b=="G"):
			print("C")





if __name__ == "__main__":
	solve ()

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

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

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

Solution (Python):
x = input()

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

print(d[x])

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

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

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

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

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

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

Solution (Python):
b = input()

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

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

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

main()

Solution (Python):
N = input()

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