qyliang/CodeNanoFix huggingface dataset:
Buggy code:
b = input()
print('A') if b == 'T'
print('T') if b == 'A'
print('C') if b == 'G'
print('G') if b == 'C'


Fixed code:
b = input()
print("T" if b == "A" else "A" if b == "T" else "G" if b == "C" else "C")
Buggy code:
b=str(input())
if b=='A':
    print('C')
elif b=='C':
    print('A')
elif b=='G':
    print('T')
else:
    print('G')


Fixed code:
b=str(input())
if b=='A':
    print('T')
elif b=='C':
    print('G')
elif b=='G':
    print('C')
else:
    print('A')
Buggy code:
s = input()

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



Fixed code:
s = input()

if s == 'A':
    print('T')
elif s == 'C':
    print('G')
elif s == 'G':
    print('C')
else:
    print('A')
Buggy code:
import sys

input = sys.stdin.readline


def main():
    b = input().rstrip()

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

    print(ans)


if __name__ == "__main__":
    main()


Fixed code:
import sys

input = sys.stdin.readline


def main():
    b = input().rstrip()

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

    print(ans)


if __name__ == "__main__":
    main()
Buggy code:
b=str(input())
print(b.translate(b.maketrans({'A':'x'},{'C':'y'},{'T':'A'},{'G':'C'},{'x':'C'},{'y':'G'})))

Fixed code:
b=str(input())
print(b.translate(b.maketrans({'A':'T','C':'G','T':'A','G':'C'})))
Buggy code:
b = input()

c = ""

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

Fixed code:
b = input()

c = ""

for d in b:
    if d=="A":
        c = c + "T"
    elif d=="C":
        c = c + "G"
    elif d=="G":
        c = c + "C"
    else:
        c = c + "A"
    
print(c)
Buggy code:
a = 'ACGT'
b = 'ATCG'
x = input()
for i in range(0, 4):
  if x[0] == a[i]:
    print(b[i])

Fixed code:
a = 'ATCG'
b = 'TAGC'
x = input()
for i in range(0, 4):
  if x[0] == a[i]:
    print(b[i])
Buggy code:
from collections import defaultdict, deque
import sys

INF = float('inf')
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]


b = S()
ans = 'T' if b == 'A' else 'A' if b == 'T' else 'C' if b == 'G' else 'C' if b == 'G'
print(ans)


Fixed code:
from collections import defaultdict, deque
import sys

INF = float('inf')
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]


b = S()
ans = 'T' if b == 'A' else 'A' if b == 'T' else 'C' if b == 'G' else 'G'
print(ans)
Buggy code:
a = input()

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

Fixed code:
a = input()

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

Fixed code:
b = input()
if b == 'A':
  print('T')
if b == 'T':
  print('A')
if b == 'G':
  print('C')
if b == 'C':
  print('G')
Buggy code:
b=input()
l=['A','C','G','T']
for i in range(4):
  if b==l[i]:
    print(l[4-i])

Fixed code:
b=input()
l=['A','C','G','T']
for i in range(4):
  if b==l[i]:
    print(l[3-i])
Buggy code:
b = input()
dic = {'A':'T', 'C':'G'}

s = dic.get(b)
if s == None:
    if b == 'T':
        print('A')
    else:
        print('C')


Fixed code:
b = input()
dic = {'A':'T', 'C':'G'}

s = dic.get(b)
if s == None:
    if b == 'T':
        print('A')
    else:
        print('C')
else:
    print(s)
Buggy code:
import sys
import math
import bisect

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


Fixed code:
import sys
import math
import bisect

def main():
    s = input()
    if s == 'A':
        print('T')
    elif s == 'C':
        print('G')
    elif s == 'G':
        print('C')
    elif s == 'T':
        print('A')
    
if __name__ == "__main__":
    main()
Buggy code:
import math
import collections
import sys

input = sys.stdin.readline
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)

Fixed code:
import math
import collections
import sys

#input = sys.stdin.readline
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")
Buggy code:
base = {'A':'A', 'C':'T', 'G':'C', 'T':'G'}

b = int(input())
print(base[b])


Fixed code:
base = {'A':'T', 'C':'G', 'G':'C', 'T':'A'}
 
b = input()
print(base[b])
Buggy code:
n = str(input())
if n == 'A':
    print('A')
elif n == 'C':
    print('T')
elif n == 'G':
    print('C')
else:
    print('G')


Fixed code:
n = str(input())
if n == 'A':
    print('T')
elif n == 'C':
    print('G')
elif n == 'G':
    print('C')
else:
    print('A')
Buggy code:
b=input()
if b="A":
  print("T")
elif b="T":
  print("A")
elif b="C":
  print("G")
else:
  print("C")

Fixed code:
b = str(input())
if (b == "A"):
 print("T")
elif(b =="T"):
 print("A")
elif(b == "C"):
 print("G")
else:
 print("C")
Buggy code:
b = input():
if b == "A":
  print("T")
elif b = "T":
  print("A")
elif b = "G":
  print("C")
elif v = "C":
  print("G")

Fixed code:
b = input()
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "G":
    print("C")
elif b == "C":
    print("G")
Buggy code:
a = input()
print('A' if a=='A' else 'T' if a == 'C' else 'C' if a=='G' else 'G')

Fixed code:
a=input()
print("T" if a=="A" else "A" if a=="T" else "C" if a=="G" else "G")
Buggy code:
b = int(input())

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

Fixed code:
b = input()
enkitsui = {'A':'T','C':'G','T':'A','G':'C'}
print(enkitsui[b])
Buggy code:
b = input():
if b == "A":
  print("T")
elif b == "T":
  print("A")
elif b == "G":
  print("C")
elif b == "C":
  print("G")

Fixed code:
b = input()

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

print(result)
Buggy code:
l = input()
if l =="A":
  print("T")
if l =="T":
  print("A")
if l =="C":
  print("G")
else:
  print("C")

Fixed code:
l = input()
if l =="A":
  print("T")
elif l =="T":
  print("A")
elif l =="C":
  print("G")
else:
  print("C")
Buggy code:
b=input()
if b="A":
  print("T")
elif b="T":
  print("A")
elif b="G":
  print("C")
else:
  print("G")
       

Fixed code:
b = input()

if b == 'A':
	print("T")
elif b == 'T':
	print("A")
elif b == 'G':
	print("C")
else:
	print("G")
Buggy code:
s=input()
if s=="C":
  print("G")
elif s=="G":
  print("C")
elif s=="A":
  print("T"):
else:
  print("A")

Fixed code:
s=input()

if s=="A":
    print("T")
elif s=="T":
    print("A")
elif s=="C":
    print("G")
else:
    print("C")
Buggy code:
b=input()
if b=='A':
  a='T'
elif b=='T':
  a='A':
elif b=='C':
  a='G':
else:
  a='C'
 print(a)

Fixed code:
b=input()
if b=='A':
    a='T'
elif b=='T':
    a='A'
elif b=='C':
    a='G'
else:
    a='C'
print(a)
Buggy code:
s=input()
if s=='A':
    print('T')
elif s=='T':
    print('A')
elif s=='C':
    print('G')
elif s=='G':
    print('G')

Fixed code:
s = input()

if s == "A":
    print("T")
elif s== "T":
    print("A")
elif s == "G":
    print("C")
else:
    print("G")
Buggy code:
b = input()
if b = 'A':
  print("T")
elif b = 'T':
  print("G")
elif b = 'G':
  print("C")
elif b = 'C':
  print("G")

Fixed code:
b = input()
ans = ''
if b == 'A':
    ans = 'T'
elif b == 'T':
    ans = 'A'
elif b == 'C':
    ans = 'G'
elif b == 'G':
    ans = 'C'
print(ans)
Buggy code:
b = input()

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


Fixed code:
b= input()
if b=="A":
    print("T")
elif b=="T":
    print("A")
elif b=="C":
    print("G")
elif b=="G":
    print("C")
Buggy code:
b = input()
a = ''
for i in range(4):
    if b[i] == 'A':
        a += 'T'
    elif b[i] == 'T':
        a += 'A'
    elif b[i] == 'C':
        a += 'G'
    elif b[i] == 'G':
        a += 'C'
print(a)


Fixed code:
b = input()
a = ''
for i in range(len(b)):
    if b[i] == 'A':
        a += 'T'
    elif b[i] == 'T':
        a += 'A'
    elif b[i] == 'C':
        a += 'G'
    elif b[i] == 'G':
        a += 'C'
print(a)
Buggy code:
b = str(input())
if b = "A":
    print("T")
elif b = "T":
    print("A")
elif b = "C":
    print("G")
elif b = "G":
    print("C")

Fixed code:
b = str(input())
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
elif b == "G":
    print("C")
Buggy code:
b = str( input() )
elist = [ "A", "C", "G", "T" ]
print( elist[ 2 - elist.index( b ) ] )

Fixed code:
b = str( input() )
elist = [ "A", "C", "G", "T" ]
print( elist[ 3 - elist.index( b ) ] )
Buggy code:
b=input
if b=='A':
    print('T')
elif b=='T':
    print('A')
elif b=='C':
    print('G')
elif b=='G':
    print('C')

Fixed code:

b = input()

if b == 'A':
    print('T')
elif b == 'T':
    print('A')
elif b == 'C':
    print('G')
elif b == 'G':
    print('C')
Buggy code:
Helix=input()
if Helix=='A':
    print ("G")
elif Helix=="G":
    print ("A")
elif Helix=="G":
    print ("C")
elif Helix=="C":
    print ("G")

Fixed code:
Helix=input()
if Helix=='A':
    print ("T")
elif Helix=="T":
    print ("A")
elif Helix=="G":
    print ("C")
elif Helix=="C":
    print ("G")
Buggy code:
b = input()

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

Fixed code:
b = input()
if b == "A":
    print("T")
if b == "C":
    print("G")
if b == "G":
    print("C")
if b == "T":
    print("A")
Buggy code:
def main():
    k = input()
    if k == "A":
        print("C")
    if k == "C":
        print("A")
    if k == "T":
        print("G")
    if k == "G":
        print("T")


if __name__ == "__main__":
    main()


Fixed code:
def main():
    k = input()
    if k == "A":
        print("T")
    if k == "T":
        print("A")
    if k == "C":
        print("G")
    if k == "G":
        print("C")


if __name__ == "__main__":
    main()
Buggy code:
b = str(input())

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

Fixed code:
b = str(input())

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

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

Fixed code:
b = input()
if b=="T":
    output = "A"
elif b=="A":
    output = "T"
elif b=="C":
    output = "G"
elif b=="G":
    output = "C"
print(output)
Buggy code:
dic = { "A": "G",
        "G": "A", 
        "T": "C",
        "C": "T" }
print(dic[input()])

Fixed code:
dic = { "A": "T",
        "T": "A",
        "G": "C",
        "C": "G" }
print(dic[input()])
Buggy code:
e_list = ['A', 'C', 'G', 'T']
b = str(input())
if b == e_list[1]:
    print(e_list[0])
elif b == e_list[0]:
    print(e_list[1])
elif b == e_list[2]:
    print(e_list[3])
elif b == e_list[3]:
    print(e_list[2])

Fixed code:
e_list = ['A', 'C', 'G', 'T']
b = str(input())
if b == e_list[0]:
    print(e_list[3])
elif b == e_list[1]:
    print(e_list[2])
elif b == e_list[2]:
    print(e_list[1])
elif b == e_list[3]:
    print(e_list[0])
Buggy code:
from sys import (stdin, stout)

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

for line in stdin:
  stdout.write(CORR_TAB[line.strip()] + '\n')

Fixed code:
from sys import (stdin, stdout)

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

for line in stdin:
  stdout.write(CORR_TAB[line.strip()] + '\n')
Buggy code:
s =  input()
if(s == "A"):
    print("F")
elif(s == "T"):
    print("A")
elif(s == "C"):
    print("G")
elif(s == "G"):
    print("C")

Fixed code:
s =  input()
if(s == "A"):
    print("T")
elif(s == "T"):
    print("A")
elif(s == "C"):
    print("G")
elif(s == "G"):
    print("C")
Buggy code:
b = input()

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

print(ans)


Fixed code:
b = input()

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

print(ans)
Buggy code:
ans ={"A":"C","C":"A","G":"T","T":"G"}
print(ans[input()])

Fixed code:
ans ={"A":"T","T":"A","G":"C","C":"G"}
print(ans[input()])
Buggy code:
b = input()

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


Fixed code:
b = input()
if b =="A":
  print("T")
elif b=="T":
  print("A")
elif b=="G":
  print("C")
else:
  print("G")
Buggy code:
A = input()
if A 　== "A":
  print("T")
elif A == "T"
  print("A")
elif A == "C"
  print("G")
elif A == "G"
  print("C")

Fixed code:
b = input()
if b=='A':
    print('T')
elif b=='T':
    print('A')
elif b=='C':
    print('G')
elif b=='G':
    print('C')
Buggy code:
dict={"A":"T","C":"G","T":"A","G":"C"}
dict[input()]

Fixed code:
dict={"A":"T","C":"G","T":"A","G":"C"}
print(dict[input()])
Buggy code:
b = input()
ans,pair = ['A','C','G','T'],['C','A','T','G']
for i,j in zip(ans,pair):
    if j == b:
        print(i)

Fixed code:
b = input()
ans,pair = ['A','C','G','T'],['T','G','C','A']
for i,j in zip(ans,pair):
    if j == b:
        print(i)
Buggy code:
b = input()
if b == A:
  print(T)
elif b == T:
  print(A)
elif b == C:
  print(G)
else:
  print(C)

Fixed code:
b = input()

if "A" == b:
    print("T")
elif "C" == b:
    print("G")
elif "G" == b:
    print("C")
else:
    print("A")
Buggy code:
# A - Double Helix
b = input()
dict_ = {"A":"A", "C":"T", "G":"C", "T":"G"}
print(dict_[b])

Fixed code:
# A - Double Helix
b = input()
dict_ = {"A":"T", "C":"G", "G":"C", "T":"A"}
print(dict_[b])
Buggy code:
# coding: utf-8

x = input()

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

Fixed code:
# coding: utf-8

x = input()

if x == 'A':
	print('T')
elif x == 'T':
	print('A')
elif x == 'G':
	print('C')
elif x == 'C':
	print('G')
Buggy code:
s = input()
ans = ''
if(s=='A'):
    ans = 'T'
elif(s=='T'):
    ans = 'A'
elif(s=='C'):
    ans = 'G'
else:
    ans= 'C'


Fixed code:
s = input()
ans = ''
if(s=='A'):
    ans = 'T'
elif(s=='T'):
    ans = 'A'
elif(s=='C'):
    ans = 'G'
else:
    ans= 'C'
print(ans)
Buggy code:
b = input()
if b == A:
  print("T")
elif b == C:
  print("G")
elif b == G:
  print("C")
else b == T:
  print("A")

Fixed code:
b = input()
if b == 'A':
    ans = 'T'
elif b == 'T':
    ans = 'A'
elif b == 'C':
    ans ='G'
else:
    ans = 'C'
print(ans)
Buggy code:
b=input()
if b=='A':
	print('T')
if b=='T':
	print('A')
if b=='C':
	print('G'):
if b=='G':
	print('C')

Fixed code:
b=input()
if b=='A':
	print('T')
if b=='T':
	print('A')
if b=='C':
	print('G')
if b=='G':
	print('C')
Buggy code:
import sys
input=sys.stdin.readline

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

Fixed code:
import sys
input=sys.stdin.readline().strip

b = input()
if b == 'A':
	print('T')
elif b == 'T':
	print('A')
elif b == 'G':
	print('C')
elif b == 'C':
	print('G')
Buggy code:
v = input()
if v = "A":
  print("T")
elif v = "T":
  print("A")
elif v = "C":
  print("G")
elif v = "G":
  print("C")

Fixed code:
v = input()
if v == "A":
  print("T")
elif v == "T":
  print("A")
elif v == "C":
  print("G")
elif v == "G":
  print("C")
Buggy code:
b = input()
b.replace('A','a').replace('T','t').replace('C','c').replace('G','g')
print(b.replace('a','T').replace('t','A').replace('c','G').replace('g','C'))

Fixed code:
b = input()
print(b.replace('A','a').replace('T','t').replace('C','c').replace('G','g').replace('a','T').replace('t','A').replace('c','G').replace('g','C'))
Buggy code:
dict = {"A":"C", "C":"A", "G":"T", "T":"G"}
print(dict[b])


Fixed code:
b = input()
dict = {"A":"T", "T":"A", "C":"G", "G":"C"}
print(dict[b])
Buggy code:
l = ['A', 'C', 'T', 'G']
b = input()
for i in range(3):
    if l[i] == b:
        print(l[(i+2)%4])
        break

Fixed code:
l = ['A', 'C', 'T', 'G']
b = input()
for i in range(4):
    if l[i] == b:
        print(l[(i+2)%4])
        break
Buggy code:
b = int(input())
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "G":
    print("C")
else:
    print("G")

Fixed code:

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

Fixed code:
b=input();print('A'if b=='T' else 'T' if b=='A' else 'G' if b=='C' else 'C')
Buggy code:
b=input()
a=['A','C','G','T']
b=['A','T','C','G']
i=a.index(b)
print(b[i])

Fixed code:
b=input()
a=['A','C','G','T']
c=['T','G','C','A']
i=a.index(b)
print(c[i])
Buggy code:
moji = input()
if moji == "A" :
    print("A")
if moji == "C" :
    print("T")
if moji == "G" :
    print("C")
if moji == "T" :
    print("G")

Fixed code:
moji = input()
if moji == "A" :
    print("T")
if moji == "C" :
    print("G")
if moji == "G" :
    print("C")
if moji == "T" :
    print("A")
Buggy code:
b = input()

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

Fixed code:
b = input()

if (b == "A") :
    print("T")
elif (b == "T") :
    print("A")
elif (b == "C") :
    print("G")
elif (b == "G") :
    print("C")
Buggy code:
b = map(int, input().split())

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

Fixed code:
b, = map(str, input().split())

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

b = input()

print(b)

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


Fixed code:

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

Fixed code:
b = input()

if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == 'C':
    print("G")
else:
    print("C")
Buggy code:
b = str(input())
dic = {'A':'C', 'C':'A', 'G':'T', 'T':'G'}
bz = dic[b]
print(bz)

Fixed code:
b = str(input())
dic = {'A':'T', 'C':'G', 'G':'C', 'T':'A'}
bz = dic[b]
print(bz)
Buggy code:
b = input()

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

Fixed code:
b = input()
if b=="A":
    print("T")
elif b=="T":
    print("A")
elif b=="C":
    print("G")
elif b=="G":
    print("C")
Buggy code:
b = int(input())

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

print(dict[b])

Fixed code:
b = input()
 
dict = {"A":"T","C":"G","T":"A","G":"C"}
 
print(dict[b])
Buggy code:
import sys


for line in sys.stdin.readlines():
    if line == 'A':
        print('T')
    if line == 'T':
        print('A')
    if line == 'C':
        print('G')
    if line == 'G':
        print('C')


Fixed code:
import sys


for line in sys.stdin.readlines():
    line=line.strip()
    if line == 'A':
        print('T')
    if line == 'T':
        print('A')
    if line == 'C':
        print('G')
    if line == 'G':
        print('C')
Buggy code:
if "A" == "b":
    print("T")
elif "T" == "b":
  print("A")
elif "C" == "b":
  print("G")
else:
  print("C")

Fixed code:
b = input()
if b=='A':
    print ('T')
elif b == 'T':
    print ('A')
elif b == ('C'):
    print ('G')
else:
    print ('C')
Buggy code:
dic = {"A" : "T", "T" : "A", "C" : "G", "G" : "C"}
print(dict[input()])

Fixed code:
dic = {"A" : "T", "T" : "A", "C" : "G", "G" : "C"}
print(dic[input()])
Buggy code:
b=input()
if b=="A":
    print("C")
elif b=="C":
    print("A")
elif b=="G":
    print("T")
else:
    print("G")

Fixed code:
b = input()
if b=='T':
  print('A')
elif b=='A':
  print('T')
elif b=='C':
  print('G')
else:
  print('C')
Buggy code:
s=input()
if s="A":
  print("T")
if s="T":
  print("A")

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

Fixed code:
s=input()
if s=="A":
  print("T")
if s=="T":
  print("A")

if s=="G":
  print("C")
if s=="C":
  print("G")
Buggy code:
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["G"])
else:
    print(d["C"])

Fixed code:
d = {"A":"T","T":"A","C":"G","G":"C"}
b = input()
#b = input()

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

Fixed code:
b=input()

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

print(ans)
Buggy code:
b = input()
if b = A: 
    print(T)
elif b = T:
    print(A)
elif b = C:
    print(G)
elif b = G:
    print(C)

Fixed code:
b = input()
if b == "A":
 print("T")
elif b == "T":
 print("A")
elif b == "C":
 print("G")
elif b == "G":
 print("C")
Buggy code:
b = input()
if b = "A": 
    print("T")
elif b = "T":
    print("A")
elif b = "C":
    print("G")
elif b = "G":
    print("C")

Fixed code:
b = input()
if b == 'A':
	print('T')
elif b == 'T':
	print('A')
elif b == 'C':
	print('G')
else:
	print('C')
Buggy code:
b = int(input())
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
else:
    print("C")

Fixed code:
b = input('')
if b == 'A':
    print('T')
elif b == 'C':
    print('G')
elif b == 'G':
    print('C')
else:
    print('A')
Buggy code:
if b=="A":
	print("T")
elif b=="T":
	print("A")
elif b=="G":
	print("C")
elif b=="C":
	print("G")



Fixed code:
b=input()

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

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

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

elif b == 'G':
    print('C')
Buggy code:
d = {"A":"T", "T":"A", "G":"C", "C","G"}
print(d[input()])

Fixed code:
d = {"A":"T", "T":"A", "G":"C", "C":"G"}
print(d[input()])
Buggy code:
s=input()
if s='A':
  print('T')
elif s='T':
  print('A')
elif s='C':
  print('G')
else:
  print('C')

Fixed code:
s=input()
if s=='A':
  print('T')
elif s=='T':
  print('A')
elif s=='C':
  print('G')
else:
  print('C')
Buggy code:
s=input();['C' if s=='G' else'G','T' if s=='A' else'A'][s in'AT']

Fixed code:
s=input();print(['C' if s=='G' else'G','T' if s=='A' else'A'][s in'AT'])
Buggy code:
i = input()
if i == "A":
    print("C")
elif i == "C":
    print("A")
elif i == "G":
    print("T")
elif i == "T":
    print("G")

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