qyliang/CodeNanoFix huggingface dataset:
Buggy code:
a,b = map(str, input().split())
if a>b:
  print(">")
elif a==b:
  print(">")
else:
  print("<")

Fixed code:
a,b = map(str, input().split())
if a>b:
  print(">")
elif a==b:
  print("=")
else:
  print("<")
Buggy code:
a,b = input ().split ()
if a < b:
  print ('<')
elif a > b:
  pritn ('>')
else:
  print ('=')

Fixed code:
a,b = input ().split ()
if a < b:
  print ('<')
elif a > b:
  print ('>')
else:
  print ('=')
Buggy code:
a,b = map(str,input().split())
A = 1
B = 2
C = 3
D = 4
E = 5
F = 6

if a < b:
    print("<")
else:
    print(">")

Fixed code:
a,b = map(str,input().split())
A = 1
B = 2
C = 3
D = 4
E = 5
F = 6
     
if a < b:
    print("<")
elif a == b:
    print("=")
else:
    print(">")
Buggy code:
X, Y = map(input().split())

if X > Y:
  print(">")
elif X < Y:
  print("<")
else:
  print("=")

Fixed code:
X, Y = input().split()

if X > Y:
    print(">")
elif X < Y:
    print("<")
else:
    print("=")
Buggy code:
X,Y = map(str,input().split())

A = 10
B = 11
C = 12
D = 13
E = 14
F = 15

if X < Y:
    print('<')
else:
    print('>')

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

A = 10
B = 11
C = 12
D = 13
E = 14
F = 15

if X < Y:
    print('<')
elif X>Y:
    print('>')
else:
    print('=')
Buggy code:
x,y = map(str,input().split())
if a < b:
  print('<')
elif a == b:
  print('=')
else:
  print('>')

Fixed code:
x, y = map(str, input().split())
if x > y: print(">")
elif x == y: print("=")
else : print("<")
Buggy code:
x, y = input().split()
if x > y:
    print('>')
else:
    print('<')

Fixed code:
x, y = input().split()
if x > y:
    print('>')
elif x == y:
    print('=')
else:
    print('<')
Buggy code:
X,Y = map(str, input().split())
if X > Y:
    print(">")
else:
    print("<")


Fixed code:
X,Y = map(str, input().split())
if X > Y:
  print(">")
elif X == Y:
  print("=")
else:
  print("<")
Buggy code:
x,y = input().split()
print('<' if x<y else '>' if x>y else '=' if x==y)

Fixed code:
x, y = input().split()
print('<' if x < y else '=' if x == y else '>')
Buggy code:
a, b = map(str, input().split())
if a == b:
  print('=')
elif min(a, b) == a:
  print('>')
else:
  print('<')

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

if a<b:
    print('<')
elif a==b:
    print('=')
else:
    print('>')
Buggy code:
X,Y=(int(i) for i in input().split())
left=ord(X)-55
right=ord(Y)-55
if left==right:
  print("=")
elif left>right:
  print(">")
else:
  print("<")

Fixed code:
X,Y=(i for i in input().split())
left=ord(X)-55
right=ord(Y)-55
if left==right:
    print("=")
elif left>right:
    print(">")
else:
    print("<")
Buggy code:
n, m = map(int, input().split())
t = 1900*m + 100*(n-m)
p = (1/2)**m
print(t/p)

Fixed code:
n, m = map(int, input().split())
t = 1900*m + 100*(n-m)
p = (2)**m
print(t*p)
Buggy code:
N, M = map(int, input().split())

time = (M * 1900 + (N-M) * 100) / (0.5 ** M)
print(time)

Fixed code:
N, M = map(int, input().split())

time = (M * 1900 + (N-M) * 100) / (0.5 ** M)
print(int(time))
Buggy code:
import sys
input = sys.stdin.readline
n,m = map(int, input().split())
print((1900*m + 100*(n − m))*2**m)

Fixed code:
import sys
input = sys.stdin.readline
n,m = map(int, input().split())
print((1900*m + 100*(n - m))*2**m)
Buggy code:
N,M=input().split()

ans=((N-M)*100+M*1900)*pow(2,M)

print(str(ans))


Fixed code:
N,M=map(int,input().split())

ans=((N-M)*100+M*1900)*pow(2,M)

print(str(ans))
Buggy code:
n, m = map(int, input().split())
print(1800*m+100*n)

Fixed code:
n, m = map(int, input().split())
print((1800*m+100*n)*2**m)
Buggy code:
n,m=map(int,input().split())
print((1800*m+100*n)*2(**m))

Fixed code:
n,m=map(int,input().split())
print((1800*m+100*n)*(2**m))
Buggy code:
n, m = map(int, input().split())
print((1800 * 2 + 100 * n) * (2 ** m))

Fixed code:
n, m = map(int, input().split())
print((1800 * m + 100 * n) * (2 ** m))
Buggy code:
N,M = map(int,input().split())

p = 1-(1/2)**M
print((1900 * M + 100 * (N - M)) / (1 - p))


Fixed code:
N,M = map(int,input().split())

p = 1-(1/2)**M
time = 1900 * M + 100 * (N - M)
ans = time / (1 - p)
print(int(ans))
Buggy code:
n, m = map(int, input().split())
x = 1900 * m - 100 * (n - m)
print(x * (2**m))

Fixed code:
n, m = map(int, input().split())
x = 1900 * m + 100 * (n - m)
print(x * (2**m))
Buggy code:
N, M = map(int, input().split())
print((100 * N + 1900 * M) * (2**M))

Fixed code:
N, M = map(int, input().split())

print((1900 * M + 100 * (N - M)) * 2 ** M)
Buggy code:
n, m = map(int, input().split())
p = (1/2)**m
x = 100*(n-m)+1900*m
print(x/p)

Fixed code:
n, m = map(int, input().split())
p = (1/2)**m
x = 100*(n-m)+1900*m
print(int(x/p))
Buggy code:
N, M = map(int, input().split())
print((1900*M+100*(N-M))2**M)


Fixed code:
N, M = map(int, input().split())
print((100*(N-M) + 1900*M)*(2**M))
Buggy code:
def solve(n, m):

    ans = ((n-m) * 100 + 1900 * m) * 2 ** m

    return ans

if __name__ == "__main__":
    n, m = [int(i) for i in input().split()]
    solve(n, m)

Fixed code:
def solve(n, m):

    ans = ((n-m) * 100 + 1900 * m) * 2 ** m
    return ans

if __name__ == "__main__":
    n, m = [int(i) for i in input().split()]
    print(solve(n, m))
Buggy code:
N,M = list(map(int,input().split()))

x = ((M - M) * 100 + 1900 * M) *(2 ** M)
print(x)

Fixed code:
N, M = map(int, input().split())
x = ((N - M) * 100 + 1900 * M) *(2 ** M)
print(x)
Buggy code:
n, m = map(int, input().split())
s100 = 100*(n - m) * 2**m
s1900 = m * 1900 * 2**m
print(s100 + s1900)
\

Fixed code:
n, m = map(int, input().split())
s100 = 100*(n - m) * 2**m
s1900 = m * 1900 * 2**m
print(s100 + s1900)
Buggy code:
n,m=map(int,input().split())
print(1800*m+100*n)*2**m

Fixed code:
n,m=map(int,input().split())
print((1800*m+100*n)*2**m)
Buggy code:
N, M = list(map(int, input().split()))
print((1900 * M + 100 * (N - M)) * (2 * M))

Fixed code:

N, M = map(int,input().split())

print((1900*M+100*(N-M))*2**M)
Buggy code:
n,m = map(int, input().split())

ans = ((n-m)*100 + m*1900)*m*2
print(ans)

Fixed code:
n,m = map(int, input().split())
print((2**m)*(1900*m+100*(n-m)))
Buggy code:
n,m = map(int,input().split())

print((1900*m+100*(n-m))//(1/2**m))

Fixed code:
n, m = map(int, input().split())
total = (1900 * m + 100 * (n-m))*(1/(1/2)**m)
print(int(total))
Buggy code:
import sys

S = list(map(int,input().split()))

N=S[0]
M=S[1]

a=(N-M)*100+M*1900

print(a)
r=2**M
print(r)

result=a*r

print(result)

Fixed code:
import sys

S = list(map(int,input().split()))

N=S[0]
M=S[1]

a=(N-M)*100+M*1900


r=2**M
result=a*r

print(result)
Buggy code:
n, m = map(int, input().split())
ans = 0
ans += m * 2 * (1900 * m + 100 * (n - m))
print(ans)


Fixed code:
n, m = map(int, input().split())
ans = (1900 * m + 100 * (n - m)) * (2**m)
print(ans)
Buggy code:
N,M = map(int.input().split())
ans = (1900*M + 100*(N-M))*(2**M)
print(ans)

Fixed code:
N, M = map(int, input().split())

print((2 ** M) * (1900 * M + 100 * (N - M)))
Buggy code:
N,M=list(map(int,input().split()))

ans=(1900*M+100*(N-M))*2^M
print(ans)

Fixed code:
N,M=list(map(int,input().split()))

ans=(1900*M+100*(N-M))*(2**M)
print(ans)
Buggy code:
N, M = map(int, input().split())
X = 100 * (N-M) + 1900 * M
Y = (1 / 2)**M
print(X * Y / ((1 - Y) ** 2))


Fixed code:
N, M = map(int, input().split())
X = 100 * (N-M) + 1900 * M
Y = (1 / 2)**M
print(int(X/Y))
Buggy code:
n, m = map(int, input().split())
ans = (1900 * m + 100 * (n - m)) / ((1 / 2) ** m)
print(ans)

Fixed code:
n, m = map(int, input().split())
ans = int((1900 * m + 100 * (n - m)) / ((1 / 2) ** m))
print(ans)
Buggy code:
N, M = map(int, input().split())
ms = 1900 * M + 100 * (N - M)
p = (1 / 2) ** M
print(ms*p**-1)

Fixed code:
N, M = map(int, input().split())
ms = 1900 * M + 100 * (N - M)
p = (1 / 2) ** M
print(int(ms*p**-1))
Buggy code:
n,m = map(int,input().split())
print((1900*m+100(n-m))*2**m)


Fixed code:
n,m = map(int,input().split())
res = (1900*m+100*(n-m))*(2**m)
print(res)
Buggy code:
N,M=map(int,input().split())
print((1900*M+100*(N-M))*(2**M)


Fixed code:
N, M = map(int, input().split())

ans = 100 * (N - M) + 1900 * M
print(ans * 2 ** M)
Buggy code:
n,m=map(int,input().split())
x=1900*m+100*(n-m)
p=1/2**m
print(x//p)


Fixed code:
n,m=map(int,input().split())
x=1900*m+100*(n-m)
p=1/2**m
print(int(x/p))
Buggy code:
N,K=map(int,input().split())
print((1900*M+100*(N-M))*2**M)

Fixed code:
N,M=map(int,input().split())
print((1900*M+100*(N-M))*(2**M))
Buggy code:
n,m=list(map(int,input().split()))

E=2**m*1900*m+100*(n-m)

print(E)

Fixed code:
n,m=list(map(int,input().split()))
E=2**m*(1900*m+100*(n-m))

print(E)
Buggy code:
n, m = map(int, input().split())
print(1900*m + 100(n - m) * 2**m)

Fixed code:
n, m = map(int, input().split())
print((100*(n-m) + 1900*m) * (2**m))
Buggy code:
N, M = map(int, input().split())

T = (N-M)*100 + M*1900
a = (1-2**(-M))

ans = 2**(-M)*T//(1-a)**2

print(ans)

Fixed code:
N, M = map(int, input().split())

T = (N-M)*100 + M*1900
a = (1-2**(-M))

ans = 2**(-M)*T//((1-a)**2)

print(int(ans))
Buggy code:
N,M = map(int,input().split())
ans = (N-M)*100+1900*M*2**M
print(ans)

Fixed code:
N,M = map(int,input().split())

ans = ((N-M)*100 + M*1900)*(2**M)
print(ans)
Buggy code:
n,m = map(int,input().split())
x = 1900*m + 100*(n-m)
p = 1/2**m
print(x//p)


Fixed code:
n,m = map(int,input().split())
x = 1900*m + 100*(n-m)
p = 1/2**m
print(int(x//p))
Buggy code:
N,M=map(input().split())

ans=(M*1900 +(N-M)*100)*(2**M)

print(ans)

Fixed code:
N,M=map(int,input().split())
ans=(M*1900 +(N-M)*100)*(2**M)

print(ans)
Buggy code:
a = input().split()
A = int(a[0])
B = int(a[1])
print(B*2*(1900*B+100*(A-B)))

Fixed code:
a = input().split()
A = int(a[0])
B = int(a[1])
print(2**B*(1900*B+100*(A-B)))
Buggy code:
import math

N,M = map(int,input().split())

T = M * 1900 + (N-M) * 100

p = (1/2)**M
p2 = (1/2)**M
ans = 0
for i in range(1,500000):
  ans += T * p2 * i
  p2 = p2 * (1-p)
  
print(math.ceil(ans))


Fixed code:
import math

N,M = map(int,input().split())

T = M * 1900 + (N-M) * 100

p = (1/2)**M
p2 = (1/2)**M
ans = 0
for i in range(1,500000):
  ans += T * p2 * i
  p2 = p2 * (1-p)
  
print(round(ans))
Buggy code:
N,M = map(int,input().split())
print(1900*M + 100*(N-M))*2**M

Fixed code:
N,M=map(int, input().split())

time=(N-M)*100+1900*M

print(time*(2**M))
Buggy code:
N,M = map(int,input().split())

T = M * 1900 + (N-M) * 100

print( int(( (1/2)**M / (1-(1-(1/2)**M)) ) *T))



Fixed code:
N,M=map(int,input().split())

T=1900*M+100*(N-M)

print(T*2**M)
Buggy code:
N,M = map(int,(input().split()))
T = 1900*M + 100*(N-M)
p = (1/2)**M
print(T//p)

Fixed code:
N,M = map(int,(input().split()))
T = 1900*M + 100*(N-M)
p = 2**M
print(T*p)
Buggy code:
# coding:utf-8

import sys
import math
import time
#import numpy as np
import collections
from collections import deque
import queue
import copy


#X = str(input()).split()
#a = [int(x) for x in input().split()]


NM = str(input()).split()
N = int(NM[0])
M = int(NM[1])

p = (1/2)**M
q = 1/p

ans = q*(M*1900)+q*((N-M)*100)

print(ans)



Fixed code:
# coding:utf-8

import sys
import math
import time
#import numpy as np
import collections
from collections import deque
import queue
import copy


#X = str(input()).split()
#a = [int(x) for x in input().split()]


NM = str(input()).split()
N = int(NM[0])
M = int(NM[1])

p = (1/2)**M
q = 1/p

ans = q*(M*1900)+q*((N-M)*100)

print(int(ans))
Buggy code:
N, M = [int(x) for x in input().split()]
print((1900 * N + 100 * (N - M)) * 2 ** M)

Fixed code:
N, M = [int(x) for x in input().split()]
print((1900 * M + 100 * (N - M)) * 2 ** M)
Buggy code:
from collections import defaultdict
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpl_s(): return list(input().split())

N,M = inpl()
T = (N-M)*100 + 1900*M
print(T)
k = 2**M
print(k*T)


Fixed code:
from collections import defaultdict
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpl_s(): return list(input().split())

N,M = inpl()
T = (N-M)*100 + 1900*M
k = 2**M
print(k*T)
Buggy code:
n, m = map(int, input().split())

print(((1900 * m) + ((n - m) * 100)) * (2 * m))

Fixed code:
n, m = map(int, input().split())

print(((1900 * m) + ((n - m) * 100)) * (2 ** m))
Buggy code:
n, m = map(int, input().split())

time = 100 * (n - m) + 19000 * m
ans = time * 2**m
print(ans)

Fixed code:
n, m = map(int, input().split())

time = 100 * (n - m) + 1900 * m
ans = time * 2**m
print(ans)
Buggy code:
n,m = map(int,input().split())
success = 0.5**m
failure = 1 - success
operation_time = 1900*m + 100*(n-m)

print(success*operation_time//((1-failure)**2))

Fixed code:
n,m = map(int,input().split())
success = 0.5**m
failure = 1 - success
operation_time = 1900*m + 100*(n-m)

print(int((success*operation_time//((1-failure)**2))))
Buggy code:
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

n, m = ri()
print((m*1900 + (n-m)*100) * 2**m)















Fixed code:
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

n, m = rm()
print((m*1900 + (n-m)*100) * 2**m)
Buggy code:
N,M=list(map(int,input().split()))
p=1/(2**M)
#print(p)
print((1900*M+100*(N-M))*1/p)

Fixed code:
N,M=list(map(int,input().split()))
p=1/(2**M)
#print(p)
print(int((1900*M+100*(N-M))*1/p))
Buggy code:
N, M = map(int,input().split())
print((1900*M + 100(N-M))*2**M)

Fixed code:
N, M = map(int, input().split())
print(((N-M) * 100 + 1900 * M) * (2 ** M))
Buggy code:
N, M=list(map(int, input().split()))
print(2**M*1900*M+100*(N-M))


Fixed code:
N, M=list(map(int, input().split()))
print(2**M*(1900*M+100*(N-M)))
Buggy code:
#http://abc078.contest.atcoder.jp/
# -*- coding: utf-8 -*-
n,m = map(int,input().split())
n = n-m
print( (1900 * m + 100 * n) * 2 ** 5 )


Fixed code:
#http://abc078.contest.atcoder.jp/
# -*- coding: utf-8 -*-
n,m = map(int,input().split())
n = n-m
print( (1900 * m + 100 * n) * 2 ** m )
Buggy code:
n,m=map(int,input().split())
x=100*n+1800*m
p=2**(-m)
print(x//p)

Fixed code:
n,m=map(int,input().split())
x=100*n+1800*m
p=2**(-m)
print(int(x/p))
Buggy code:
N,M = map(int,input().split())

ans = 1900 * M + 100 + (N - M)
ans *= pow(2,M)
print(ans)


Fixed code:
N, M = map(int, input().split())
ans = (N - M) * 100 + M * 1900
print(ans * 2 ** M)
Buggy code:
N,M = map(int,input().split())
print((1900*M+100*(N-m))*2**M)


Fixed code:
N,M=map(int,input().split())
print(2**M*(1900*M+100*(N-M)))
Buggy code:
N ,M=map(float,input().split())
print(int((1900*M+100*(N-M)*2**M))


Fixed code:
N ,M=map(float,input().split())
print(int((1900*M+100*(N-M))*2**M))
Buggy code:
N, M = map(int, input().split())
print(2*M*(1900*M+100*(N-M)))

Fixed code:
N, M = map(int, input().split())

print((M * 1900 + ((N - M) * 100)) * 2 ** M)
Buggy code:

N, M = map(int, input().rstrip().split(' '))

print(((1900*M) + (N - M)) * 2**M)

Fixed code:
N, M = map(int, input().rstrip().split(' '))
 
print(((1900*M) + (N - M) * 100) * 2**M)
Buggy code:
N, M = [int(x) for x in input().split()]

print(M * 1900+(N-M)*100)*(2**M)




Fixed code:
N, M = [int(x) for x in input().split()]

ans = (2**M) *(100 * (N - M) + 1900 * M)

print(ans)
Buggy code:
N, M = list(map(int, input().split()))
print((M * 1900 + (N - M) * 100) * pow(2, 5))

Fixed code:
N, M = list(map(int, input().split()))
print((M * 1900 + (N - M) * 100) * pow(2, M))
Buggy code:
a=list(map(int, input().split()))

m=a[0]
n=a[1]

b=(1900*m+100*(n-m))*(2**m)
print(b)

Fixed code:
a=list(map(int, input().split()))

n=a[0]
m=a[1]

b=(1900*m+(100*(n-m)))*(2**m)
print(b)
Buggy code:
n,m=map(int,input().split())
print(int((1900*m+100*(n-m)))*(2*m))


Fixed code:
n, m = map(int, input().split())

ans = (1900 * m + 100 * (n - m)) * 2 ** m

print(ans)
Buggy code:
n, m = map(int, input().split())
s = (1900*m + (n-m)*100)*n*2**m
print(s)

Fixed code:
n, m = map(int, input().split())
s = (1900*m + (n-m)*100)*2**m
print(s)
Buggy code:
n,m = map(int,input().split())

print( 1900*m+100*(n-m)*2**m )


Fixed code:
n,m = map(int,input().split())

print( (1900*m+100*(n-m))*2**m )
Buggy code:
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))

n,m=nii()

ms=1900*m+100*(n-m)
print(ms)

ans=0
for i in range(1,10**6):
  p1=0.5**m
  p2=(1-0.5**m)**(i-1)
  p=p1*p2
  t_ms=ms*i
  ans+=p*t_ms

ans=int(ans)
q=ans%10
if q!=0:
  ans+=10-q

print(ans)

Fixed code:
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))

n,m=nii()

ms=1900*m+100*(n-m)

ans=0
for i in range(1,10**6):
  p1=0.5**m
  p2=(1-0.5**m)**(i-1)
  p=p1*p2
  t_ms=ms*i
  ans+=p*t_ms

ans=int(ans)
q=ans%10
if q!=0:
  ans+=10-q

print(ans)
Buggy code:
n,m=map(int,input().split())
s=m*1900+(n-m)*100
print(sec*2**m)

Fixed code:
n,m=map(int,input().split())
s=m*1900+(n-m)*100
print(s*2**m)
Buggy code:
N,M = map(int,input().split())
ans = (N-M) * 100
ans += M*1900
ans *= 2*M
print(ans)

Fixed code:
N,M = map(int,input().split())
ans = (N-M) * 100
ans += M*1900
ans *= 2**M
print(ans)
Buggy code:
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    n, m = list(map(int, readline().split()))
    t1 = n - m
    t2 = m
    print((t1 * 100 + t2 * 1900) / (1 / 2) ** t2)


if __name__ == '__main__':
    solve()


Fixed code:
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    n, m = list(map(int, readline().split()))
    t1 = n - m
    t2 = m
    print(int((t1 * 100 + t2 * 1900) / (1 / 2) ** t2))


if __name__ == '__main__':
    solve()
Buggy code:
n, m = map(int, input().split())

ans = 2**m + (1900*m + 100*(n-m))
print(ans)

Fixed code:
n,m=map(int,input().split())
print(((n-m)*100+1900*m)*(2**m))
Buggy code:
def solve(N, M):
    p = 1 / pow(0.5, M)
    return ((N - M) * 100 + M * 1900) * p

if __name__ == "__main__":
    N, M = tuple(map(int, input().split(" ")))
    print(solve(N, M))


Fixed code:
def solve(N, M):
    p = 1 / pow(0.5, M)
    return int(((N - M) * 100 + M * 1900) * p)

if __name__ == "__main__":
    N, M = tuple(map(int, input().split(" ")))
    print(solve(N, M))
Buggy code:
x = input()
y = input()
print("YES" if x=y[::-1] else "NO")

Fixed code:
x = input()
y = input()
print("YES" if x==y[::-1] else "NO")
Buggy code:
c11, c12, c13 = list(raw_input())
c21, c22, c23 = list(raw_input())
result = c11 == c23 and \
    c12 == c22 and \
    c13 == c21

ans = "YES" if result else "NO"
print ans

Fixed code:
c11, c12, c13 = list(input())
c21, c22, c23 = list(input())
result = c11 == c23 and \
    c12 == c22 and \
    c13 == c21

ans = "YES" if result else "NO"
print(ans)
Buggy code:
l=[input() for i in range()]
print("YES" if l[0][0]==l[1][2] and l[0][1]==l[1][1] and l[0][2]==l[1][0] else "NO")

Fixed code:
l=[input() for i in range(2)]
print("YES" if l[0][0]==l[1][2] and l[0][1]==l[1][1] and l[0][2]==l[1][0] else "NO")
Buggy code:
C11, C12, C13 = map(str, input().split())
C21, C22, C23 = map(str, input().split())
if C11+C12+C13==C23+C22+C21:
  print('YES')
else:
  print('NO')

Fixed code:
C11, C12, C13 = map(str, input())
C21, C22, C23 = map(str, input())
if C11+C12+C13==C23+C22+C21:
    print('YES')
else:
    print('NO')
Buggy code:
C1 = input()
C2 = input()
print(C1,C2)

if C1[0] == C2[2] and\
    C1[1] == C2[1] and\
    C1[2] == C2[0]:
        print("YES")
else:
    print("NO")

Fixed code:
C1 = input()
C2 = input()

if C1[0] == C2[2] and\
    C1[1] == C2[1] and\
    C1[2] == C2[0]:
        print("YES")
else:
    print("NO")
Buggy code:
s_a = input()
s_b = input()
if s_a[0] == s_b[2] and s_a[2] == s_a[0] and s_a[1] == s_b[1]:
    print("YES")
else:
    print("NO")

Fixed code:
s_a = input()
s_b = input()
if s_a[0] == s_b[2] and s_a[2] == s_b[0] and s_a[1] == s_b[1]:
    print("YES")
else:
    print("NO")
Buggy code:
a=input().split()
a=list(a)
b=input().split()
b=list()
n=len(a)
N=1
for i in range(n):
  if(a[i]!=b[-(i+1)]):
    N=0
if(N==1):
  print("YES")
else:
  print("NO")
  

Fixed code:
a=input()
a=list(a)
b=input()
b=list(b)
n=len(a)
N=1
for i in range(n):
 if(a[i]!=b[-(i+1)]):
    N=0
if(N==1):
   print("YES")
else:
   print("NO")
Buggy code:
li_a=list(input())
li_b=list(input())
li_a.reverse()
if li_a==li_b:
    print(YES)
else:
    print(NO)


Fixed code:
li_a=list(input())
li_b=list(input())
li_a.reverse()
if li_a == li_b:
    print("YES")
else:
    print("NO")
Buggy code:
a=input()
a=list(a)
b=input()
b=list(b)
n=len(a)
j=1
for i in range(n):
  if(a[i]!=b[n-i]):
    j=0
if(j==1):
  print("YES")
else:
  print("NO")
   

Fixed code:
a=input()
a=list(a)
b=input()
b=list(b)
n=len(a)
j=1
for i in range(n):
  if(a[i]!=b[-(i+1)]):
    j=0
if(j==1):
  print("YES")
else:
  print("NO")
Buggy code:
c=input()
d=input()
if c[0]==d[3] and c[1]==d[1] and c[2]==d[0]:
  print("YES")
else:
  print("NO")

Fixed code:
c=input()
d=input()
if c[0]==d[2] and c[1]==d[1] and c[2]==d[0]:
  print("YES")
else:
  print("NO")
Buggy code:
s1 = list(input())
s2 = list(input())
if s1[0] == s2[2] and s1[1] == s2[2] and s1[2] == s2[0]:
  print("YES")
else:
  print("NO")

Fixed code:
s1 = list(input())
s2 = list(input())
if s1[0] == s2[2] and s1[1] == s2[1] and s1[2] == s2[0]:
  print("YES")
else:
  print("NO")
Buggy code:
c = [list(input()) for _ in range(2)]
if c[0][0] == c[1][2] and c[0][1] == c[1][1] and c[0][2] == c[1][0]:
    print('YES')
else: 
    print('No')

Fixed code:
c = [list(input()) for _ in range(2)]
if c[0][0] == c[1][2] and c[0][1] == c[1][1] and c[0][2] == c[1][0]:
    print('YES')
else: 
    print('NO')
Buggy code:
s1=input()
s2=input()
s3=s2[::-1]

if s1=s3:
    print("YES")
else:
    print("NO")

Fixed code:
s1=input()
s2=input()
s3=s2[::-1]

if s1==s3:
    print("YES")
else:
    print("NO")
Buggy code:
s1=input()
s2=input()

cnt=0
for i in range(len(l1)):
    print(l1[i])
    print(l2[-i-1])
    if l1[i]==l2[-i-1]:
        cnt+=1

if cnt == 3:
    print("YES")
else:
    print("NO")

Fixed code:
s1=input()
s2=input()

cnt=0
for i in range(len(s1)):
    if s1[i]==s2[-i-1]:
        cnt+=1

if cnt == 3:
    print("YES")
else:
    print("NO")
Buggy code:
C1 = input()
C2 = input()
ans = 'YES'
if C1[0] != C2[2]:
  ans = 'NO'
if C1[1] != C2[1]:
  ans = 'NO'
if C1[2] != C2[1]:
  ans = 'NO'
print(ans)

Fixed code:
C1 = input()
C2 = input()
ans = 'YES'
if C1[0] != C2[2]:
  ans = 'NO'
if C1[1] != C2[1]:
  ans = 'NO'
if C1[2] != C2[0]:
  ans = 'NO'
print(ans)
Buggy code:
a=input()
b=input'()
print('YES' if a[-1::-1]==b else 'NO')

Fixed code:
a=input()
b=input()
print('YES' if a[-1::-1]==b else 'NO')
Buggy code:
c1=input()
c2=input()
if c1[0]==c2[2] and c1[1]==c2[2] adn c1[2]==c2[0]:
  print('YES')
else:
  print('NO')

Fixed code:
c1 = input()
c2 = input()

if c1[0] == c2[2] and c1[1] == c2[1] and c1[2] == c2[0]:
    print("YES")
else:
    print("NO")
Buggy code:
C1 = list(input())
C2 = list(input())
if C1[0] == C2[2] and C1[1] == C2[1] and C1[2] == C2[0]:
    print('YES')
else:
    print('No')

Fixed code:
C1 = list(input())
C2 = list(input())
if (C1[0] == C2[2]) and (C1[1] == C2[1]) and (C1[2] == C2[0]):
    print('YES')
else:
    print('NO')
Buggy code:
for x,y in zip(input(),reversed(input)):
  if x!=y:
    print('NO')
    break
else:
  print('YES')


Fixed code:
for x,y in zip(input(),reversed(input())):
  if x!=y:
    print('NO')
    break
else:
  print('YES')
Buggy code:
a = input()
b = input()

b_reverse = a[::-1]

if a == b_reverse:
  print('YES')
else:
  print('NO')

Fixed code:
a = input()
b = input()

b_reverse = b[::-1]

if a == b_reverse:
  print('YES')
else:
  print('NO')