qyliang/CodeNanoFix huggingface dataset:
Buggy code:
A, B = [int(i) for i in input().split()]
List = [A+B, A-B, A*B]
List = sorted(List)
print(List[3])

Fixed code:
A, B = [int(i) for i in input().split()]
List = [A+B, A-B, A*B]
List = sorted(List)
print(List[2])
Buggy code:
a, b= map(int, input().split())

c=a+b
d=a-b
e=a*b

print(max[c, d, e])

Fixed code:
a, b= map(int, input().split())
 
c=a+b
d=a-b
e=a*b
 
f=max([c, d, e])
 
print(f)
Buggy code:
A, B = map(input().split())
print(max(A+B, A-B, A*B))

Fixed code:
A,B=map(int,input().split())

print(max(A+B,A*B,A-B))
Buggy code:
a, b = int(input())
s = a+b
t = a-b
p = a*b
li = [s, t, p]
li.sort()
print(li[-1])

Fixed code:
a, b = map(int, input().split())
s = a+b
t = a-b
p = a*b
li = [s, t, p]
li.sort()
print(li[-1])
Buggy code:
A, B = map(int, raw_input().split())

array = [A + B, A - B, A * B]
max = array[0]
if max < array[1]:
    max = array[1]
if max < array[2]:
    max = array[2]

print(max)


Fixed code:
A, B = map(int, input().split())

array = [A + B, A - B, A * B]
max = array[0]
if max < array[1]:
    max = array[1]
if max < array[2]:
    max = array[2]

print(max)
Buggy code:
def Add_Sub_Mul(a , b):

    return min(a + b , a - b , a * b)

def main():
    a , b = map(int , input().split())
    print(Add_Sub_Mul(a , b))

if __name__ == '__main__':
    main()

Fixed code:
def Add_Sub_Mul(a , b):

    return max(a + b , a - b , a * b)

def main():
    a , b = map(int , input().split())
    print(Add_Sub_Mul(a , b))

if __name__ == '__main__':
    main()
Buggy code:
a, b = map(int,input().split())

print(max[a+b,a-b,a*b])

Fixed code:
a,b=map(int,input().split())
l=[a+b,a-b,a*b]
print(max(l))
Buggy code:
a, b = map(int, input().split())
print(max(a + b, a - b, a * b)

Fixed code:
a,b = map(int,input().split())
print(max(max(a+b,a-b),a*b))
Buggy code:
li = list(map(int,input().split()))
ans = [li[0]+li[1],li[0]-li[1],li[1]-li[0],li[0]*li[1]].sort()
print(ans[3])

Fixed code:
li = list(map(int,input().split()))
ans = [li[0]+li[1],li[0]-li[1],li[0]*li[1]]
ans.sort()
print(ans[2])
Buggy code:
a, b map(int, input().split())
c=a+b
d=a-b
e=a*b
print(max([c,d,e]))

Fixed code:
a, b = map(int, input().split())
c=a+b
d=a-b
e=a*b
print(max([c,d,e]))
Buggy code:
a, b=map(int, input().split())
print(a+b, a-b, a*b)

Fixed code:
a, b= map(int,input().split())
print(max(a+b, a-b, a*b))
Buggy code:
a,b = map(int,input().split(" "))
print(max([a+b,a-b,a*b])

Fixed code:
a,b = map(int,input().split(" "))
print(max([a+b,a-b,a*b]))
Buggy code:
num=input().split()
a=int(num[0])
b=int(num[1])
print(max[a+b,a-b,a*b,a/b])

Fixed code:
num=input().split()
a=int(num[0])
b=int(num[1])
print(max([a+b,a-b,a*b]))
Buggy code:
def main(a, b):
    add = a + b
    sub = a - b
    mul = a * b

    return max(add, sub, mul)


if __name__ == "__main__":
    a, b = input().split(' ')
    print(main(a, b))


Fixed code:
def main(a, b):
    add = a + b
    sub = a - b
    mul = a * b

    return max(add, sub, mul)


if __name__ == "__main__":
    a, b = map(int, input().split(' '))
    print(main(a, b))
Buggy code:
a, b, c = list(map(int, input().split()))
my_result = max(a+b, a-b, a*b)
print(my_result)

Fixed code:
a, b = list(map(int, input().split()))
my_result = max(a + b, a - b, a * b)
print(my_result)
Buggy code:
A, B = map(int, input().split())
X = A + B
Y = A - B
Z = A * B
if X > Y and X > Z:
    print(X)
elif Y > X and Y >Z:
    print(Y)
elif Z > X and Z > Y:
    print(Z)

Fixed code:
A, B = map(int, input().split())
X = A + B
Y = A - B
Z = A * B
if X >= Y and X >= Z:
    print(X)
elif Y >= X and Y >= Z:
    print(Y)
elif Z >= X and Z >= Y:
    print(Z)
Buggy code:
a, b = map(int(int, input().split()));print(max(a+b,a-b,a*b))

Fixed code:

a, b = map(int, input().split())

print(max(a+b,a-b,a*b))
Buggy code:
N=input().split()
A=N[0]
B=N[1]
Ans=A+B
if(Ans<A-B):
  Ans=A-B
  
if(Ans<A*B):
  Ans=A*B
  
print(Ans)

Fixed code:
N=input().split()
A=int(N[0])
B=int(N[1])
Ans=A+B
if(Ans<A-B):
  Ans=A-B
  
if(Ans<A*B):
  Ans=A*B
  
print(Ans)
Buggy code:
a, b = map(int(int, input().split()))
print(max([a+b,a-b,a*b]))

Fixed code:
a,b = list(map(int,input().split()))
print(max([a * b,a -b,a + b]))
Buggy code:
a,b,c = map(int,input().split())

print(max(a+b,a-b,a*b))

Fixed code:
a,b=map(int,input().split())
print(max(a+b,max(a-b,a*b)))
Buggy code:
A, B = map(int, input().split())
print(max(A+B,
          A-B,
          A*X))

Fixed code:
A, B = map(int, input().split())
print(max(A+B,
          A-B,
          A*B))
Buggy code:
a,b = [int(x) for x in input().split()]
ans = max([a+b, a-b, a*b])

Fixed code:
a,b = [int(x) for x in input().split()]
ans = max([a+b, a-b, a*b])
print(ans)
Buggy code:
a,b =map(int,input().split())
print(max(a+b,a-b,a*b)

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

print(max(a+b,a-b,a*b))
Buggy code:
a, b = map(int, input().split())

x = a + b
y = a - b
z = a * b

print(max[x, y, z])

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

x = a + b
y = a - b
z = a * b

print(max([x, y, z]))
Buggy code:
A, B = map(int,input().split())
print(str(max(A+B, A-B., A*B)))

Fixed code:
A, B = map(int,input().split())
print(str(max(A+B, A-B, A*B)))
Buggy code:
a,b=map(int, input().split())
print(max([A+B,A-B,A*B])

Fixed code:
a, b = map(int, input().split())
A = [a+b, a-b, a*b]
print(max(A))
Buggy code:
a,b=map(int,input().split())
print(max[a*b,a+b,a-b])

Fixed code:
a, b = map(int, input().split())
calcs = [a + b, a - b, a * b]
print(max(calcs))
Buggy code:
a=list(map(int,input().split()))
if a[0]+a[1]>a[0]-a[1]&a[0]+a[1]>a[0]*a[1]:
    print(a[0]+a[1])
elif a[0]*a[1]>a[0]+a[1]&a[0]*a[1]>a[0]-a[1]:
    print(a[0]*a[1])
else :
    print(a[0]-a[1])

Fixed code:
a=list(map(int,input().split()))
if (a[0]+a[1]>a[0]-a[1])&(a[0]+a[1]>a[0]*a[1]):
    print(a[0]+a[1])
elif (a[0]*a[1]>a[0]+a[1])&(a[0]*a[1]>a[0]-a[1]):
    print(a[0]*a[1])
else :
    print(a[0]-a[1])
Buggy code:
a, b = map(int, input().split())

print(max(a+b, a-b, a*b)

Fixed code:
a, b = map(int, input().split())
 
print(max(a+b, a-b, a*b))
Buggy code:
A,B=map(int,input().split())
print(max(A+B),(A-B),(A*B))


Fixed code:
A, B = map(int, input().strip().split())

print(max(max(A + B, A - B), A * B))
Buggy code:
a,b = map(int, input().split())
print(max(a+b, b-a, a*b))

Fixed code:

a, b = input().split()

a = int(a)
b = int(b)

print(max(a-b, max(a+b, a*b)))
Buggy code:
a,b=map(int,input().split())

if  (type(a)=b==int) and (-1000 <= a=b <=1000):
    print(max(a+b,a-b,a*b))


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

if  (type(a)==int) and( type(b)==int) and (-1000 <= a and 1000>=a ) and (-1000 <= b and 1000>=b ):
    print(max(a+b,a-b,a*b))
Buggy code:
A, B = map(int, input().split())
print(max(A+B, A-B, A*B)

Fixed code:

A, B = map(int, input().split())

print(max(A+B,A-B,A*B))
Buggy code:
print((lambda x:max(eval(x[0]+c+x[1])for c in"*+-"))(input()))

Fixed code:
print((lambda x:max(eval(x[0]+c+x[1])for c in"*+-"))(input().split()))
Buggy code:
A,B = map(int,input().split())

print(max(A+B,A-B,A*B)


Fixed code:
A, B = list(map(int, input().split()))
print(max(A + B, A - B, A * B))
Buggy code:
a=list(map(int,input.split()))
print(max(a[0]+a[1],a[0]-a[1],a[0]*a[1]))


Fixed code:
a=list(map(int,input().split()))
print(max(a[0]+a[1],a[0]-a[1],a[0]*a[1]))
Buggy code:
a,b=map (int,input ().split ())
print (max [a+b,a-b,a*b])

Fixed code:
(a, b) = list(map(int, input().split()))
print(max([a + b, a - b, a * b]))
Buggy code:
a=input()
b=a.split()
c=[int(i) for i in b]
t=c[0]+c[1]
h=c[0]-c[1]
k=c[0]*c[1]
ans=max([t,h,c])
print(ans)

Fixed code:
a=input()
b=a.split()
c=[int(i) for i in b]
t=c[0]+c[1]
h=c[0]-c[1]
k=c[0]*c[1]
ans=max([t,h,k])
print(ans)
Buggy code:
a,b = map(int, input().split())
print(max(a+b,a-b,a*b)

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

print(max(a+b,a-b,a*b))
Buggy code:
a,b=list(map(int,input().split()))
print(max(a+b,a-b,a*b)

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

print(max(a+b,max(a-b,a*b)))
Buggy code:
a,b=list(map(int,input().split()))
print(max([a+b,a-b,a*b])

Fixed code:
a,b=list(map(int,input().split()))
print(max([a+b,a-b,a*b]))
Buggy code:
A,B = map(int,input().split())

print('{}'.format(max([A+B,A-B,A*B,A/B])))

Fixed code:
A,B = map(int,input().split())

print('{}'.format(max([A+B,A-B,A*B])))
Buggy code:
a,b = map(int,input().split())
print(max(a+b,a-b,a*b)

Fixed code:
a,b=map(int,input().split())
print((max(a+b,a-b,a*b)))
Buggy code:
a,b = map(lambda x: int(x) for x in input().split())

print(max(a+b, a-b, a*b))

Fixed code:
a,b = map(lambda x: int(x), input().split())

print(max(a+b, a-b, a*b))
Buggy code:
a,b=map(int,input().split())
max(a+b,a-b,a*b)

Fixed code:
a, b = map(int, input().split())
print(max(a+b,a-b,a*b))
Buggy code:
A, B = map( int, input().split())

C1 = A + B
C2 = A - B
C3 = A * B

C = [ C1, C2, C3 ]

C = sorted.C

print(C[2])



Fixed code:
A, B = map( int, input().split())
C = []

C1 = A + B
C.append(C1)

C2 = A - B
C.append(C2)

C3 = A * B
C.append(C3)

C = sorted(C)

print(C[2])
Buggy code:
# -*- coding: utf-8 -*-
import sys
# ----------------------------------------------------------------
# Use Solve Function

def solve(lines):
    A,B = map(int, lines.pop(0).split(' '))
    print(max( A+B, A-B, A*B ))

#
# main
#

# 1. use list instead of stdin

#contents = '''\
#3 -4\
#'''
lines = contents.split('\n')

# 2. use stdin

lines = [x.strip() for x in sys.stdin.readlines()]

#
# solve !!
#
solve(lines)

Fixed code:
# -*- coding: utf-8 -*-
import sys
# ----------------------------------------------------------------
# Use Solve Function

def solve(lines):
    A,B = map(int, lines.pop(0).split(' '))
    print(max( A+B, A-B, A*B ))

#
# main
#

# 1. use list instead of stdin

#contents = '''\
#3 -4\
#'''
#lines = contents.split('\n')

# 2. use stdin

lines = [x.strip() for x in sys.stdin.readlines()]

#
# solve !!
#
solve(lines)
Buggy code:
a,b = map(int,input().split())
max(a+b,a-b,a*b)

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

print(max((a+b),(a-b), (a*b)))
Buggy code:
A,B=list(map(int, input().split()))
max(A+B, A-B, A*B)

Fixed code:
A,B=list(map(int, input().split()))
print(max(A+B, A-B, A*B))
Buggy code:
A, B = map(int, input().split())
print(max([A+B. A-B, A*B]))


Fixed code:
A,B=map(int,input().split())
ans=[A+B,A-B,A*B]
print(max(ans))
Buggy code:
# -*- coding: utf-8 -*-
A,B = [int(i) for i in input().split()]

if A+B >= A-B and A+B >= A*B:
    print(A+B)
if A-B >= A+B and A-B >= A*B:
    print(A-B)
if A*B >= A+B and A*B >= A-B:
    print(A*B)


Fixed code:
# -*- coding: utf-8 -*-
A,B = [int(i) for i in input().split()]

if A+B >= A-B and A+B >= A*B:
    print(A+B)
elif A-B >= A+B and A-B >= A*B:
    print(A-B)
elif A*B >= A+B and A*B >= A-B:
    print(A*B)
Buggy code:
a, b, c=map(int, input().split())
print(max((a+b), (a-b), (a*b)))

Fixed code:
a, b=map(int, input().split())
print(max((a+b), (a-b), (a*b)))
Buggy code:
num = input().split()
a, b =int(num[0]), int(num[1])

ans = sorted([a+b, a-b, a*b , a//b])

print(ans[0])

Fixed code:
num = input().split()
a, b =int(num[0]), int(num[1])

ans = sorted([a+b, a-b, a*b])

print(ans[-1])
Buggy code:
from sys import stdin

A, B = stdin.readline().rstrip().split()


a = int(A)
b = int(B)
print(type(A))
print(max(a+b, a-b, a*b))

Fixed code:
from sys import stdin

A, B = stdin.readline().rstrip().split()
a = int(A)
b = int(B)

print(max(a+b, a-b, a*b))
Buggy code:
A, B = map(int, input().split())

add = A + B
sub = A - B
mul = A * B

if add > sub and add > mul:
    print(add)
elif sub > add and sub > mul:
    print(sub)
elif mul > add and mul > sub:
    print(mul)


Fixed code:
A, B = map(int, input().split())

add = A + B
sub = A - B
mul = A * B

if add > sub and add > mul:
    print(add)
elif sub > add and sub > mul:
    print(sub)
elif mul > add and mul > sub:
    print(mul)
else:
    print(add)
Buggy code:
a,b = map(int,input().split())
print(max(a+b.a-b,a*b))

Fixed code:
a,b = map(int, input().split())
ans = max(a+b, a-b, a*b)
print(ans)
Buggy code:
a, b = map(lambda x: int(x), input().split())

lis = [a+b, a-b, a*c]
print(max(lis))

Fixed code:
a, b = map(lambda x: int(x), input().split())

lis = [a+b, a-b, a*b]
print(max(lis))
Buggy code:
A,B=map(int,input().split())
X=A*B
Y=A-B
X=A+B
print(max(X,Y,Z))

Fixed code:
A,B=map(int,input().split())
X=A*B
Y=A-B
Z=A+B
print(max(X,Y,Z))
Buggy code:
a,b=map(int,input().split())
c=[a-b,b-a,a*b]
c.sort()
print(c[2])

Fixed code:
a,b=map(int,input().split())
c=[a+b,a-b,a*b]
c.sort()
print(c[2])
Buggy code:
A, B = map(int,input().split())

print(A+B, A-B, A*B)

Fixed code:
A, B = map(int,input().split())

print(max(A+B, A-B, A*B))
Buggy code:
a, b, c = map(int, input().split())

print(max([a+b, a-b, a*b]))

Fixed code:
a,b = map(int,input().split())
print(max([(a+b),(a-b),(a*b)]))
Buggy code:
a,b,c,d = list(map(int,input().split(" ")))

if max(a,b)-min(a,b)<=d and max(b,c)-min(b,c)<=d:
    print("Yes")
else:
    print("No")

Fixed code:
a,b,c,d = list(map(int,input().split(" ")))
 
if max(a,b)-min(a,b)<=d and max(b,c)-min(b,c)<=d or max(a,c)-min(a,c)<=d:
    print("Yes")
else:
    print("No")
Buggy code:
a,b,c,d = map(int,input().split())
if abs(b-a) <= d and abs(c-b) <= d:
  print("Yes")
else:
  print('No')

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

if abs(a-c) <= d:
  print('Yes')
elif abs(a-b) <= d and abs(b-c) <= d:
  print('Yes')
else:
  print('No')
Buggy code:
a,b,c,d = map(int, input().split())
if b - a > d or c -b > d:
    print("Yes")
else:
    print("No")

Fixed code:
a,b,c,d = map(int,input().split())
if((abs(a-b)>d or abs(b-c)>d) and abs(a-c)>d):
    print("No")
else:
    print("Yes")
Buggy code:
a,b,c,d = map(int,input().split())
if b-a <= d and c-b <= d:
  print("Yes")
else:
  print('No')

Fixed code:
a, b, c, d = map(int,input().split())

if abs(b-a)<=d and abs(c-b)<=d:
    print("Yes")
elif abs(c-a)<=d:
    print("Yes")
else:
    print("No")
Buggy code:
a, b, c, d = map(int, input().split())

if abs(a-c) <= d:
    print('Yes')
if abs(a-b) <= d:
    if abs(b-c) <= d:
        print('Yes')
    else:
        print('No')
else:
    print('No')

Fixed code:
a,b,c,d=map(int,input().split())
if abs(b-c)<=d & abs(a-b)<=d:
    print('Yes')
elif abs(a-c)<=d:
    print('Yes')
else:
    print('No')
Buggy code:
a, b, c, d = map(int, input().split())

if abs(a-c) <= d:
    print('Yes')
if abs(a-b) <= d and abs(b-c) <= d:
    print('Yes')
else:
    print('No')

Fixed code:
a,b,c,d=map(int,input().split())
print("Yes" if abs(c-a)<=d or (abs(a-b)<=d and abs(b-c)<=d) else "No")
Buggy code:
a, b, c, d = map(int, input().split())

if abs(a-b) <= d and abs(b-c) <= d:
  print('Yes')
else:
  print('No')

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

if abs(a - c) <= d:
    print('Yes')
elif abs(a - b) <= d and abs(c - b) <= d:
    print('Yes')
else:
    print('No')
Buggy code:
a,b,c,d = map(int,input().split())

result = 'No'
d1 = b-a
if c-a <= d:
    result = 'Yes'
elif b-a <= d and c-b <= d:
    result = 'Yes'

print(result)

Fixed code:
a,b,c,d = map(int,input().split())

result = 'No'
d1 = b-a
if abs(c-a) <= d:
    result = 'Yes'
elif abs(b-a) <= d and abs(c-b) <= d:
    result = 'Yes'

print(result)
Buggy code:
a,b,c,d = map(int, input().split())

print("Yes" if abs(b-a) <= d and abs(c-b) <= d else "No")

Fixed code:
a,b,c,d = map(int, input().split())

print("Yes" if (abs(b-a) <= d and abs(c-b) <= d) or abs(a-c) <= d else "No")
Buggy code:
a, b, c, d = map(int, input().split())

AB = abs(a - b)
BC = abs(b - c)
AC = abs(a - c)

if AB < d and BC < d:
    print("Yes")
elif AC < d:
    print("YES")
else:
    print("No")

Fixed code:
a, b, c, d = map(int, input().split())

AB = abs(a - b)
BC = abs(b - c)
AC = abs(a - c)

if AC <= d:
    print("Yes")
elif AB <= d and BC <= d:
    print("Yes")
else:
    print("No")
Buggy code:
A,B,C,D = map(int,input().split())
if abs(A-C)<=D:
  print('Yes')
else:
  if abs(A-B)<=D an abs(B-C)<=D:
    print('Yes')
  else:
    print('No')

Fixed code:
A,B,C,D = map(int,input().split())
if abs(A-C)<=D:
  print('Yes')
else:
  if abs(A-B)<=D and abs(B-C)<=D:
    print('Yes')
  else:
    print('No')
Buggy code:
a, b, c, d = map(int, input().split())

if max(b-a,c-d) <= d or (c-a) <= d:
    print("Yes")
else:
    print("No")

Fixed code:
a, b, c, d = map(int,input().split())
print('Yes' if abs(a-c) <= d or max(abs(a-b),abs(b-c)) <= d else 'No')
Buggy code:
a,b,c,d=map(int, input().split())
E=b-a
F=c-b
G=c-a
if E<=d and F<=d:
	print("Yes")
elif G<=d:
	print("Yes")
else:
	print("No")

Fixed code:
a,b,c,d=map(int, input().split())
E=abs(b-a)
F=abs(c-b)
G=abs(c-a)
if E<=d and F<=d:
	print("Yes")
elif G<=d:
	print("Yes")
else:
	print("No")
Buggy code:
a,b,c,d=map(int,input().split())

if(abs(a-c)<=d):
	print(a-c)
	print("Yes")
elif((abs(a-b)<=d and abs(b-c)<=d) == True):
	print("Yes")
else:
	print("No")

Fixed code:
a,b,c,d=map(int,input().split())

if(abs(a-c)<=d):
	print("Yes")
elif((abs(a-b)<=d and abs(b-c)<=d) == True):
	print("Yes")
else:
	print("No")
Buggy code:
a,b,c,d=map(int,input().split())
if abs(c-a)<d or (abs(b-a) < d and abs(c-b) < d):
  print("Yes")
else:
  print("No")

Fixed code:
a,b,c,d=map(int, input().split())
print('Yes' if (abs(a-c)<=d or (abs(a-b)<=d and abs(b-c)<=d)) else 'No')
Buggy code:
a, b, c, d = map(int, input().split())
print("Yes" if max(b-a, c-b) <= d else "No")

Fixed code:
a, b, c, d = map(int, input().split())
print("Yes" if min(max(abs(b-a), abs(c-b)), abs(a-c)) <= d else "No")
Buggy code:
num = input().split()
a, b, c, d = int(num[0]), nt(num[1]), nt(num[2]), nt(num[3])

if abs(a-b)<=d and abs(b-c)<=d:
  print("Yes")
else:
  print("No")

Fixed code:
num = input().split()
a, b, c, d = int(num[0]), int(num[1]), int(num[2]), int(num[3])

if abs(a-b)<=d and abs(b-c)<=d or abs(a-c) <= d:
  print("Yes")
else:
  print("No")
Buggy code:
a,b,c,d = map(int,input().split())
if abs(a-c) or (abs(a-b)<=d and abs(b-c)<=d):
  print("Yes")
else:
  print("No")

Fixed code:
a,b,c,d=map(int,input().split())

if abs(a-c)>d and (abs(a-b)>d or abs(b-c)>d):
    print("No")
else:
    print("Yes")
Buggy code:
a,b,c,d = map(int,input().split())
if (b-a <= d and c-b <= d) or c-a <= d:
  print("Yes")
else:
  print("No")

Fixed code:
a, b, c, d = map(int, input().split())
if (abs(a-b)<=d and abs(b-c)<=d) or abs(a-c)<=d :
  print ('Yes')
else:
  print ('No')
Buggy code:
A, B, C, D = list(map(int,input().split()))
ab = abs(A-B)
bc = abs(B-C)
if ab <= D and bc <= D:
  print("Yes")
else:
  print("No")

Fixed code:
A, B, C, D = list(map(int,input().split()))
ab = abs(B - A)
bc = abs(C - B)
ca = abs(C - A)
if ab <= D and bc <= D or ca <= D:
  print("Yes")
else:
  print("No")
Buggy code:
list1 = [int(a) for a in input().split()]
m_a = list1[0] #a
m_b = list1[1] #b
m_c = list1[2] #c
m_d = list1[3] #d

m_e = abs(m_a - m_c)

if m_e <= m_d:
    print("Yes")
else:
    print("No")

Fixed code:
list1 = [int(a) for a in input().split()]
m_a = list1[0] #a
m_b = list1[1] #b
m_c = list1[2] #c
m_d = list1[3] #d

if abs(m_a - m_c) <= m_d:
    print("Yes")
elif abs(m_b - m_c) <= m_d:
    if abs(m_b - m_a) <= m_d:
        print("Yes")
    else:
        print("No")
else:
    print("No")
Buggy code:
a,b,c,d = map(int,input().split())
if b-a <= d and c-b <= d:
    print('Yes')
else:
    print('No')

Fixed code:
a,b,c,d = map(int,input().split())
if abs(a-c) <= d:
    print("Yes")
elif abs(a-b) <= d and abs(b-c)<= d:
    print("Yes")
else:
    print("No")
Buggy code:
a, b, c, d = map(int, input().split())

if abs(a-b) <= d and abs(b-c) <= d:
    print("Yes")

else:
    print("No")


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

if abs(a-b) <= d and abs(b-c) <= d:
    print('Yes')
elif abs(a-c) <= d:
    print('Yes')
else:
    print('No')
Buggy code:
a,b,c,d=map(int,input().split())
a='Yes'
if abs(a-c)>d:
  if abs(a-b)>d or abs(b-c)>d:
    a='No'
print(a)

Fixed code:
a,b,c,d=map(int,input().split())
s='Yes'
if abs(a-c)>d:
  if abs(a-b)>d or abs(b-c)>d:
    s='No'
print(s)
Buggy code:
a,b,c,d =map(int, input().split())
if abs(a-c)<=d:
  print("Yes")
  return
if a<=b<=c or c<=b<=a:
  if abs(a-b)<=d and abs(c-b)<=d:
    print("Yes")
    return
print("No")

Fixed code:
a,b,c,d =map(int, input().split())
ans="No"
if abs(a-c)<=d:
  ans ="Yes"
if a<=b<=c or c<=b<=a:
  if abs(a-b)<=d and abs(c-b)<=d:
    ans="Yes"
print(ans)
Buggy code:
a,b,c,d = map(int,input().split())
print("Yes" if abs(a-b)<=d and abs(b-c)<=d else "No")

Fixed code:
a,b,c,d = map(int, input().split())
print('Yes' if abs(a-b)<=d and abs(b-c)<=d or abs(a-c)<=d else 'No')
Buggy code:
# -*- coding: utf-8 -*-

def main():
    a, b, c, d = map(int, input().split())
    print('Yes' if abs(c-a)>= d or abs(a-b)<=d and abs(b-c)<=d else 'No')

if __name__ == '__main__':
    main()

Fixed code:
# -*- coding: utf-8 -*-

def main():
    a, b, c, d = map(int, input().split())
    print('Yes' if abs(c-a)<= d or abs(a-b)<=d and abs(b-c)<=d else 'No')

if __name__ == '__main__':
    main()
Buggy code:
a,b,c,d = map(int,input().split())
if abs(a-b)<=d:
        if abs(b-c)<=d:
                print("Yes")
else:
        print("No")


Fixed code:
a, b, c, d = map(int, input().split())

if abs(a - b) <= d and abs(b - c) <= d or abs(a - c) <= d:
    print('Yes')
else:
    print('No')
Buggy code:
a,b,c,d = map(int,input().split())
if abs(c - a) <= d:
    print('Yes')
elif abs(b - a) <= d and abs(c - d) <= d:
    print('Yes')
else:
    print('No')

Fixed code:
a, b, c, d = map(lambda x: int(x), input().split())
 
if abs(a - c) <= d:
  print('Yes')
elif abs(a - b) <= d and abs(b - c) <= d:
  print('Yes')
else:
  print('No')
Buggy code:
a, b, c, d = map(int, input().split())

ab = abs(a-b)
bc = abs(b-c)
ac = abc(a-c)

if ac <= d or (ab <= d and bc <= d):
  print('Yes')
else:
  print('No')

Fixed code:
a, b, c, d = map(int, input().split())

ab = abs(a-b)
bc = abs(b-c)
ac = abs(a-c)

if ac <= d or (ab <= d and bc <= d):
  print('Yes')
else:
  print('No')
Buggy code:
line = input().split(' ')
a, b, c, d = int(line[0]), int(line[1]), int(line[2]), int(line[3])

if abs(a-c) < d:
	print('Yes')
else:
	if abs(a-b) < d and abs(b-c) < d:
		print('Yes')
	else:
		print('No')

Fixed code:
line = input().split(' ')
a, b, c, d = int(line[0]), int(line[1]), int(line[2]), int(line[3])

if abs(a-c) <= d:
	print('Yes')
else:
	if abs(a-b) <= d and abs(b-c) <= d:
		print('Yes')
	else:
		print('No')
Buggy code:
a, b, c, d = (int(_) for _ in input().split())  

if max(abs(a-b),abs(b-c)) <= d:
  print("Yes")
else:
  print("No")



Fixed code:
a, b, c, d = (int(_) for _ in input().split())  

if max(abs(a-b),abs(b-c)) <= d or abs(a-c) <= d:
  print("Yes")
else:
  print("No")
Buggy code:
a,b,c,d=map(int,input().split())
e=abs(a-b)
f=abs(b-c)
if e>=d and f>=d:
  print("Yes")
else:
  print("No")

Fixed code:
a,b,c,d=map(int,input().split())
e=abs(a-b)
f=abs(b-c)
g=abs(a-c)
if g>d and (e>d or f>d):
  print("No")
else:
  print("Yes")
Buggy code:
a,b,c,d=map(int,input().split())
print(['No','Yes'][(d<=abs(a-b) and d<=abs(b-c)) or d<=abs(a-c)])

Fixed code:
a,b,c,d=map(int,input().split())
print(['No','Yes'][(d>=abs(a-b) and d>=abs(b-c)) or d>=abs(a-c)])
Buggy code:
a, b, c, d = map(int,input().split())
if abs(a-c) < d or ((abs(c-b) < d  and abs(b-a) < d) and (a<b and b<c)) or((abs(c-b) < d  and abs(b-a) < d) and (a>b and b>c)) :
	print('Yes')
else:
	print('No')


Fixed code:
a,b,c,d = map(int,input().split())
if abs(a-c)<=d or (abs(a-b)<=d and abs(b-c)<=d):
      print("Yes")
else:
      print("No")
Buggy code:
a,b,c,d = list(map(int, input().split()))

if abs(a - c) <= d:
    print("Yes")

elif abs(a-b) <= d and ans(b-c) <= d:
    print("Yes")

else:
    print("No")


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

if abs(a - c) <= d:
    print("Yes")

elif abs(a-b) <= d and abs(b-c) <= d:
    print("Yes")

else:
    print("No")
Buggy code:
a, b, c, d=map(int,input().split)
k1=abs(a-b)
k2=abs(a-c)
k3=abs(b-c)
if (k2<=d):
  print("Yes")
elif (k1<=d || k2<=d):
  print("Yes")
else print("No")

Fixed code:
a, b, c, d=map(int,input().split())
k1=abs(a-b)
k2=abs(a-c)
k3=abs(b-c)
if k2<=d:
  print("Yes")
elif k1<=d and k3<=d:
  print("Yes")
else:
  print("No")
Buggy code:
A,B,C,D=input().split()
A=int(A)
B=int(B)
C=int(C)
D=int(D)
if (abs(C-B)<D and abs(B-A)<D) or abs(C-A)<D :
    print("Yes")
else :
    print("No")

Fixed code:
A,B,C,D=input().split()
A=int(A)
B=int(B)
C=int(C)
D=int(D)
if (abs(C-B)<=D and abs(B-A)<=D) or abs(C-A)<=D :
    print("Yes")
else :
    print("No")