qyliang/CodeNanoFix huggingface dataset:
Buggy code:
import heapq
hq=[]
X, Y, Z, K= map(int,input().split())
A=list(map(int,input().split()))
A.sort(reverse=True)
B=list(map(int,input().split()))
B.sort(reverse=True)
C=list(map(int,input().split()))
C.sort(reverse=True)
searched={(0,0,0)}
heapq.heappush(hq,(-(A[0]+B[0]+C[0]),0,0,0))
D=[[1,0,0],[0,1,0],[0,0,1]]

for _ in range(K):
    abc,x,y,z=heapq._heappop_max(hq)
    print(-abc)
    for dx,dy,dz in D:
        if x+dx<X and y+dy < Y and z+dz < Z and (x+dx,y+dy,z+dz) not in searched:
            heapq.heappush(hq,(-(A[x+dx]+B[y+dy]+C[z+dz]),x+dx,y+dy,z+dz))
            searched.add((x+dx,y+dy,z+dz))

Fixed code:
import heapq
hq=[]
X, Y, Z, K= map(int,input().split())
A=list(map(int,input().split()))
A.sort(reverse=True)
B=list(map(int,input().split()))
B.sort(reverse=True)
C=list(map(int,input().split()))
C.sort(reverse=True)
searched={(0,0,0)}
heapq.heappush(hq,(-(A[0]+B[0]+C[0]),0,0,0))
D=[[1,0,0],[0,1,0],[0,0,1]]

for _ in range(K):
    abc,x,y,z=heapq.heappop(hq)
    print(-abc)
    for dx,dy,dz in D:
        if x+dx<X and y+dy < Y and z+dz < Z and (x+dx,y+dy,z+dz) not in searched:
            heapq.heappush(hq,(-(A[x+dx]+B[y+dy]+C[z+dz]),x+dx,y+dy,z+dz))
            searched.add((x+dx,y+dy,z+dz))
Buggy code:
X, Y, Z, K = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
AB = []
ans = []
for a in A:
    for b in B:
        AB.append(a + b)
AB.sort(reverse=True)
AB = AB[:min(3001,X*Y*Z+1)]
for c in C:
    for ab in AB:
        ans.append(c + ab)
ans.sort(reverse=True)
for i in range(k):
    print(ans[i])


Fixed code:
X, Y, Z, K = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
AB = []
ans = []
for a in A:
    for b in B:
        AB.append(a + b)
AB.sort(reverse=True)
AB = AB[:min(3001, X*Y*Z+1)]
for c in C:
    for ab in AB:
        ans.append(c + ab)
ans.sort(reverse=True)
for i in range(K):
    print(ans[i])
Buggy code:
X, Y, Z, K= map(int,input().split())
A=list(map(int,input().split())).sort(reverse=True)
B=list(map(int,input().split())).sort(reverse=True)
C=list(map(int,input().split())).sort(reverse=True)

ABC=[]
for i in range(X):
    for j in range(Y):
        for k in range(Z):
            if (i+1)*(j+1)*(k+1)>K:
                break
            else:
                ABC.append(X[i]+Y[j]+Z[k])
                
ABC.sort(reverse=True)

for i in range(K):
    print(ABC[i])

Fixed code:
X, Y, Z, K= map(int,input().split())
A=list(map(int,input().split()))
A.sort(reverse=True)
B=list(map(int,input().split()))
B.sort(reverse=True)
C=list(map(int,input().split()))
C.sort(reverse=True)

ABC=[]
for i in range(X):
    for j in range(Y):
        for k in range(Z):
            if (i+1)*(j+1)*(k+1)<=K:
                ABC.append(A[i] + B[j] + C[k])
            else:
                break

ABC.sort(reverse=True)

for i in range(K):
    print(ABC[i])
Buggy code:
x,y,z,k = map(int,input().split())
a = list(map(int,input().split())).sort(reverse=True)
b = list(map(int,input().split())).sort(reverse=True)
c = list(map(int,input().split())).sort(reverse=True)

sum_list = []
for a_i in range(x):
    for b_i in range(y):
        for c_i in range(z):
            if a_i*b_i*c_i > k:
                continue
            sum_list.append(a[a_i]+b[b_i]+c[c_i])
sum_list.sort(reverse=True)
for i in range(k):
    print(sum_list[i])

Fixed code:
x,y,z,k = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
c = list(map(int,input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
sum_list = []
for a_i in range(x):
    for b_i in range(y):
        if a_i*b_i > k:
            break
        for c_i in range(z):
            if a_i*b_i*c_i > k:
                break
            sum_list.append(a[a_i]+b[b_i]+c[c_i])
sum_list.sort(reverse=True)
for i in range(k):
    print(sum_list[i])
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 = str(input())

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

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

ans = cou.index(b)
print(ans)

Fixed code:
b = input()

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

ans = cou[big.index(b)]
print(ans)
Buggy code:
b = input()
if b == "A":
  pair = "T"
elif b == "T":
  pair = "A":
elif b == "C":
  pair = "G"
else:
  pair = "C"
print(pair)

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

if b=='A':
  print "T"
if b=='c':
  print "G"
if b=='G':
  print "C"
if b=='T':
  print "A"

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

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

Fixed code:
base = input()

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

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

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

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

print(ans)

Fixed code:
S = input()
ans = ""
if S == "A":
  ans = "T"
elif S == "T":
  ans = "A"
elif S == "C":
  ans = "G"
elif S == "G":
  ans = "C"

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

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


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

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

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


Fixed code:
x = input()
if x == 'A':
    print('T')
elif x == 'T':
    print('A')
elif x == 'G':
    print('C')
else:
    print('G')
Buggy code:
l1 = ['A','T']
l2 = ['C','G']
b = str(input())
print(b)
ans = ''
if b in l1:
    l1.remove(b)
    ans = t1[0]
if b in l2:
    l2.remove(b)
    ans = l2[0]
print(ans)

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

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

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

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


Fixed code:
def main():
    b = input()
    argc = len(b)
    data = []
    for i in range(argc):
#       print(b[i])
      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()
Buggy code:
m = {'A':'T', 'T':'A', 'G':'C', 'C':'G'}
print(m[input())

Fixed code:
m = {'A':'T', 'T':'A', 'G':'C', 'C':'G'}
print(m[input()])
Buggy code:
s = input()

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


Fixed code:
s = input()

if s=="A":
  print("T")
if s=="T":
  print("A")
if s=="C":
  print("G")
if s=="G":
  print("C")
Buggy code:
b = input()
i = ['A','C','G','T']
o = ['C','A','T','G']
print(o[i.index(b)])

Fixed code:
b = input()
i = ['A','C','G','T']
o = ['T','G','C','A']
print(o[i.index(b)])
Buggy code:
s = input()
if s = "A":
  print("T")
elif s = "C":
  print("G")
elif s = "G":
  print("C")
elif s = "T":
  print("A")

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

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

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

Fixed code:
I=input()

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

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

s = sys.stdin.readline()
if s == 'A':
    print('T')
elif s == 'G':
    print('C')
elif s == 'C':
    print('G')
else:
    print('A')


Fixed code:
import sys

s = sys.stdin.readline()
if 'A' in s:
    print('T')
elif 'G' in s:
    print('C')
elif 'C' in s:
    print('G')
else:
    print('A')
Buggy code:
code = str(input())
if code = 'A':
	print('T')
elif code = 'T':
    print('A')
elif code = 'G':
    print('C')
elif code = 'C':
    print('G')

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

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

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

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


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

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

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

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

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

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

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

Fixed code:
b = input()

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

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

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

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

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

print(data[b])

Fixed code:
b = str(input())

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

print(data[b])
Buggy code:
print('ATCG'['TAGC'.index()])

Fixed code:
print('ATCG'['TAGC'.index(input())])
Buggy code:
b = input()
if b == "A":
  print("C")
elif b == "C":
  print("A"):
elif b == "T":
  print("G"):
elif b == "G":
  print("T"):



Fixed code:
b=input()
if b== 'A':
  print('T')
elif b== 'T':
  print('A')
elif b== 'C':
  print('G')
else:
  print('C')
Buggy code:
#!/usr/bin/python

def main():
    b = input()
    print(pair(b))

def pair(x: str) -> str:
    if x == "A":
        return "T"
    elif x == "T":
        return "A"
    elif x == "G":
        return "T"
    elif x == "C":
        return "G"


if __name__ == "__main__":
    main()

Fixed code:
#!/usr/bin/python

def main():
    b = input()
    print(pair(b))

def pair(x: str) -> str:
    if x == "A":
        return "T"
    elif x == "T":
        return "A"
    elif x == "G":
        return "C"
    elif x == "C":
        return "G"


if __name__ == "__main__":
    main()
Buggy code:
import sys
from operator import itemgetter
import collections


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


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

    print(r(s))


if __name__ == '__main__':
    main()


Fixed code:
import sys
from operator import itemgetter
import collections


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


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

    print(r(s))


if __name__ == '__main__':
    main()
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 == "G":
    ans = "C"
else:
    ans = "G"

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

Fixed code:
s = str(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()
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:
n = input()

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


Fixed code:
n = input()

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

Fixed code:
s=input()
print('T' if s=='A' else 'G' if s=='C' else 'A' if s=='T' else '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 == 'C':
    print('G')
elif b == 'G':
    print('C')
elif b == 'T':
    print('A')
Buggy code:
a = ["A", "C", "G", "T"]
b=input()
print(a[:-1-a.index(b)])

Fixed code:
a = ["A", "C", "G", "T"]
b=input()
print(a[-1-a.index(b)])
Buggy code:
b = input().strip()
d = {"A": "C", "G": "T", "C": "A", "T": "G"}
print(d[b])

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

def f(b):
  if(b!="A" and b!="T" and b!="C" and b!="G"):
    print("error")
  elif(b=="A"):
  	return "T"
  elif(b=="T"):
  	return "A"
  elif(b=="C"):
  	return "G"
  elif(b=="C"):
  	return "G"
  
print(f(b))
    

Fixed code:
b=input()
 
def f(b):
  if(b!="A" and b!="T" and b!="C" and b!="G"):
    print("error")
  elif(b=="A"):
  	return "T"
  elif(b=="T"):
  	return "A"
  elif(b=="C"):
  	return "G"
  elif(b=="G"):
  	return "C"
  
print(f(b))
Buggy code:
b=input()

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

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

Fixed code:
a = input()

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

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

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

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

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

arg = input()

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

print(arg)

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

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

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

Fixed code:
b = input()

if b =="A":
  ret = "T"
elif b == "T": 
  ret = "A"
elif b == "G": 
  ret = "C"
elif b == "C": 
  ret = "G"
print(ret)
Buggy code:
a='ATCG'
a['TAGC'.index(input())]


Fixed code:
a='ATCG'
print(a['TAGC'.index(input())])
Buggy code:
s=input()
if s=="A":
	print("T")
elif s=="C":
	print("G")
elif s=="T":
	print("A")
else:
	print("G")

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

if s == 'A':
  print('T')
elfi 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:
b = ''
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 == 'C':
  print('G')
elif b == 'G':
  print('C')
else:
  pass
Buggy code:
b = ''
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 == "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')
else:
  print('G')

Fixed code:
b = str(input())

if b == 'A':
  print('T')
elif b == 'T':
  print('A')
elif b == 'G':
  print('C')
else:
  print('G')
Buggy code:
# -*- coding: utf-8 -*-
"""
Created on Mon Apr  1 22:23:40 2019

@author: Owner
"""
a = []
b = list(input())

for item in b:
    if item == "A":
        item_mod = item.replace("A","T")
    if item == "G":
        item_mod = item.replace("G","C")
    if item == "T":
        item_mod = item.replace("T","A")
    if item == "C":
        item_mod = item.replace("C","G")
    a.append(item_mod)
print(a)

Fixed code:
# -*- coding: utf-8 -*-
"""
Created on Mon Apr  1 22:23:40 2019

@author: Owner
"""
a = []
b = str(input())

for item in b:
    if item == "A":
        item_mod = item.replace("A","T")
    if item == "G":
        item_mod = item.replace("G","C")
    if item == "T":
        item_mod = item.replace("T","A")
    if item == "C":
        item_mod = item.replace("C","G")
    a.append(item_mod)
print(a[0])
Buggy code:
b = input()

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

print(ans)


Fixed code:
b = input()

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

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

Fixed code:
b=input()

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