qyliang/CodeNanoFix huggingface dataset:
Buggy code:
x,a,b = list(map(int, input().split()))
if b <= a:
  print("delicious")
elif a<b and b <= x:
  print("safe")
else:
  print("dangerous")

Fixed code:
x,a,b = list(map(int, input().split()))
if b <= a:
  print("delicious")
elif a<b and b <= a+x:
  print("safe")
elif a+x < b:
  print("dangerous")
Buggy code:
X, A, B = map(int, input().split())
if B-A <= 0:
    print('delicious')
elif B-A<=X:
    print('safe')
else:
    print('dengerous')

Fixed code:
X, A, B = map(int, input().split())
if B-A <= 0:
    print('delicious')
elif B-A<=X:
    print('safe')
else:
    print('dangerous')
Buggy code:
x, a, b = map(int,input().split())

if a >= b:
  print("delicious")
  
if (a + x) >= b:
  print("safe")
  
else:
  print("dangerous")
  

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

if b>a+x:
    print("dangerous")
elif b>a:
    print("safe")
else :
    print("delicious")
Buggy code:
X, A, B = map(int, input().split())

if (B-A) <= 0:
  print('delicious')
elif (B-A) <= X:
  print('safe')
else:
  print('dengerous')


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

if (B-A) <= 0:
  print('delicious')
elif (B-A) <= X:
  print('safe')
else:
  print('dangerous')
Buggy code:
a,s,d=map(int,input().split())
if s-d>=0:
  print("delicious")
elif a+s-d>=-:
  print("safe")
else:
  print("dangerous")

Fixed code:
a,s,d=map(int,input().split())
if s-d>=0:
  print("delicious")
elif a+s-d>=0:
  print("safe")
else:
  print("dangerous")
Buggy code:
a = list(map(int,input().split()))
if a[1] <= a[2]:
  print("delicious")
elif (a[2] - a[1]) <= a[0]:
  print("safe")
else:
  print("dangerous")

Fixed code:
a = list(map(int,input().split()))
if a[1] >= a[2]:
  print("delicious")
elif (a[2] - a[1]) <= a[0]:
  print("safe")
else:
  print("dangerous")
Buggy code:
X, A, B = map(int, input().split())

if A >= B:
    print('delicious')
elif A + X < B:
    print('dengerous')
else:
    print('safe')

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

if A >= B:
    print('delicious')
elif A + X < B:
    print('dangerous')
else:
    print('safe')
Buggy code:
x,a,b=[int(i) for i in input().split()]
if a-b>=0:
    print("delicious")
elif x>=b-a:
    print("safe")
else:
    print("denderous")

Fixed code:
x,a,b=[int(i) for i in input().split()]
if a-b>=0:
    print("delicious")
elif x>=b-a:
    print("safe")
else:
    print("dangerous")
Buggy code:
x, a, b = map(int, input().split())

if a <= b:
    print('delicious')
elif a + x <= b:
    print('safe')
else:
    print('dangerous')

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

if a >= b:
    print('delicious')
elif a + x >= b:
    print('safe')
else:
    print('dangerous')
Buggy code:
x, a, b = map(int, input().split())

if a <= b:
    print('delicious')
elif a + x <= b:
    print('safe')
else:
    print('dagerous')

Fixed code:
x,a,b = map(int, input().split())
if b <= a:
  print("delicious")
elif a < b <= a+x:
  print("safe")
else:
  print("dangerous")
Buggy code:
a,b,c=map(int,input().split())
if b-c>a:
  print("dangerous")
elif b>c:
  print("safe")
else:
  print("delicious")

Fixed code:
a,b,c=map(int,input().split())
if c-b>a:
  print("dangerous")
elif c>b:
  print("safe")
else:
  print("delicious")
Buggy code:
def main():
    x,a,b = map(int,input().split())
    now = b - a
    if now < 0:
        print("delicious")
    elif now <= x:
        print("save")
    else:
        print("dangerous")

if __name__ == '__main__':
    main()


Fixed code:
def main():
    x,a,b = map(int,input().split())
    now = b - a
    if now <= 0:
        print("delicious")
    elif now <= x:
        print("safe")
    else:
        print("dangerous")

if __name__ == '__main__':
    main()
Buggy code:
x,a,b=map(int,input().split())
if b-a<0:
  print("dalicious")
elif b-a>=0 and x-(b-a)>=0:
  print("safe")
else:
  print("dangerous")


Fixed code:
x,a,b=map(int,input().split())
if b-a<=0:
  print("delicious")
elif b-a>0 and x-(b-a)>=0:
  print("safe")
else:
  print("dangerous")
Buggy code:
X,A,B= map(int,input().split())
print('dngerous' if X<B-A else 'safe' if B>A else'delicious')

Fixed code:
X, A, B = map(int, input().split())
print("delicious" if A >= B else "safe" if B - A <= X else "dangerous")
Buggy code:
x,a,b = map(int,input().split())
if b-a <= 0:
    print("delicious")
elif a+x <= b:
    print("safe")
else:
    print("dangerous")

Fixed code:
x,a,b=map(int,input().split())
if x<b-a:
  print("dangerous")
elif 0<b-a:
  print("safe")
else:
  print("delicious")
Buggy code:
x,a,b = list(map(int, input().split()))
if -a + b <= 0:
    print("delicious")
elif -a + b <= x:
    print("safe")
else:
    print("dangers")


Fixed code:
x,a,b = list(map(int, input().split()))
if -a + b <= 0:
    print("delicious")
elif -a + b <= x:
    print("safe")
else:
    print("dangerous")
Buggy code:
x ,a , b  = map(int, input().split())
if a-b>0:
    print('delicious')
elif a+x>=b:
    print('safe')
elif a+x < b:
    print('dengerous')



Fixed code:
x ,a , b  = map(int, input().split())
if a-b>=0:
    print('delicious')
elif a+x>=b:
    print('safe')
elif a+x < b:
    print('dangerous')
Buggy code:
x,a,b=map(int,input().split())
if b-a<=0:
  print("delicious")
elif b-a=0 and x-(b-a)>=0:
  print("safe")
else:
  print("dangerous")


Fixed code:
x, a, b = map(int, input().split())
if b <= a:
    print('delicious')
elif x >= (b-a):
    print('safe')
else:
    print('dangerous')
Buggy code:
x, a, b = map(int, input().strip().split())
if a - b >= 0:
    print('delicions')
elif b - a < x:
    print('safe')
else:
    print('dangerous')


Fixed code:
x, a, b = map(int, input().strip().split())
if a - b >= 0:
    print('delicious')
elif b - a <= x:
    print('safe')
else:
    print('dangerous')
Buggy code:
#ABC065A
X, A, B = map(int, input().split())
if A-B > 0:
    print("delicious")
if B-A < X+1:
    print("safe")
else:
    print("dangerous")

Fixed code:
#ABC065A
X, A, B = map(int, input().split())
if A-B >= 0:
    print("delicious")
elif B-A < X+1:
    print("safe")
else:
    print("dangerous")
Buggy code:
if __name__=="__main__":
    x, a ,b = input().split()
    if b - a <= 0:
        print("delicious")
    elif b - a <= x:
        print("safe")
    else:
        print("dangerous")


Fixed code:
if __name__=="__main__":
    x, a ,b = map(int, input().split())
    if b - a <= 0:
        print("delicious")
    elif b - a <= x:
        print("safe")
    else:
        print("dangerous")
Buggy code:
X,A,B = map(int,input().split())

if A <= X:
    print('delicious')
elif X <= B - A:
    print('dangerous')
else:
    print("safe")


Fixed code:
X,A,B = map(int,input().split())
if B <= A:
  print('delicious')
elif B-A <= X:
  print('safe')
else:
  print('dangerous')
Buggy code:
x,a,b=map(int,input().split())
if a > b:
  print('delicious')
elif a < b < x:
  print('safe')
else:
  print('dangerous')

Fixed code:
x,a,b=map(int,input().split())
if a>=b:
  print("delicious")
elif b<=(a+x):
  print("safe")
else:
  print("dangerous")
Buggy code:
x, a, b = map(int, input().split())

if b <= a:
  print("delicious")
if b >= a and a+x <= b :
  print("safe")
if a+b < b :
  print("dangerous")

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

if b <= a:
  print("delicious")
elif  b > a and a+x >= b :
  print("safe")
elif a+x < b :
  print("dangerous")
Buggy code:
x,a,b=map(int,input().split())
k=-a+b

if k<=0:
    print('delicious')
elif k<=x:
    print('safer')
else:
    print('dangerous')

Fixed code:
x,a,b=map(int,input().split())
k=-a+b

if k<=0:
    print('delicious')
elif k<=x:
    print('safe')
else:
    print('dangerous')
Buggy code:
X, A, B = map(int, input().split())

print(X, A, B)

if A >= B:
    print('delicious')

elif A + X >= B:
    print('safe')

else:
    print('dangerous')

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

if A >= B:
    print('delicious')

elif A + X >= B:
    print('safe')

else:
    print('dangerous')
Buggy code:
x,a,b = map(int, input().spilit())
if(a>=b):
  print("delicious")
else:
  if(b-a >x):
    print("dangerous")
  else:
    print("safe")

Fixed code:
x,a,b = map(int, input().split())
if(a>=b):
  print("delicious")
else:
  if(b-a >x):
    print("dangerous")
  else:
    print("safe")
Buggy code:
X,A,B=map(int, input().split())
if A>=B:
  print('delicious')
elif A+X>=N:
  print('safe')
else:
  print('dangerous')

Fixed code:
# A
X, A, B = map(int, input().split())
if A >= B:
    print('delicious')
elif A + X >= B:
    print('safe')
else:
    print('dangerous')
Buggy code:
# -*- coding: utf-8 -*-

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

print('dangerous' if x + a - b < 0 else 'delicious')


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

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

if x + a - b < 0:
    print('dangerous')
elif a - b >= 0:
    print('delicious')
else:
    print('safe')
Buggy code:
x,a,b = (int(i) for i in input().split())

if b-a <= 0:
    print("delicious")
elif b-a > x:
    print("safe")
else:
    print("delicious")

Fixed code:
x,a,b = (int(i) for i in input().split())

if b-a <= 0:
    print("delicious")
elif b-a <= x:
    print("safe")
else:
    print("dangerous")
Buggy code:
X, A, B = map(int, input().split())

if A>=B:
  print('delicious')
elif B-A>=X:
  print('safe')
else:
  print('dangerous')


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

if A>=B:
  print('delicious')
elif B-A<=X:
  print('safe')
else:
  print('dangerous')
Buggy code:
a,b,c=map(int,input().split())
print('delicious' if b<c else 'safe' if c-b<a else 'dengerous'))

Fixed code:
a,b,c=map(int,input().split())
print('delicious' if c<=b else 'safe' if c-b<=a else 'dangerous')
Buggy code:
X,A,B=map(int,input().split())
if A-B>=0:
  print("delicious")
eilf B-A<=X:
  print("safe")
else:
  print(dangerous)

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

if B -A <= 0:
    print("delicious")
else:
    if B-A <= X:
        print("safe")
    else:
        print("dangerous")
Buggy code:
X, A, B = map(int, input().split())
if A <= B:
    print("delicious")
elif (B-A) <= X:
    pirnt("safe")
else:
    print("dangerous")

Fixed code:
X,A,B = map(int,input().split())
if A < B:
    if B - A <= X:
        print("safe")
    else:
        print("dangerous")
else:
    print("delicious")
Buggy code:
X,A,B = map(int,input().split())
if A >= B:
    print("delicious")
elif A < B and B - A <= X:
    print("safe")
else:
    print("dangerious")
    

Fixed code:
X,A,B = map(int,input().split())
if A >= B:
    print("delicious")
elif A < B and B - A <= X:
    print("safe")
else:
    print("dangerous")
Buggy code:
X, A, B = map(int, input().split())
if A <= B:
    print("delicious")
if (B-A) <= X:
    print("safe")
if X < (B-A):
    print("dangerous")


Fixed code:
X, A, B = map(int, input().split())
if B <= A:
    print("delicious")
else:
    if (B-A) <= X:
        print("safe")
    if (B-A) > X:
        print("dangerous")
Buggy code:
x, a, b = list(map(int, input().split()))
if b-a <= 0:
    print("delicious")
elif b-a < x+1:
    print("safe")
else:
    print("dengerous")

Fixed code:
x, a, b = list(map(int, input().split()))
if b-a <= 0:
    print("delicious")
elif b-a < x+1:
    print("safe")
else:
    print("dangerous")
Buggy code:
x, a, b = map(int, input().split())
print('delicious' if a >= b else 'safe' x >= b-1 else 'dangerous')

Fixed code:
x, a, b = map(int, input().split())
print('delicious' if a >= b else 'safe' if x >= b-a else 'dangerous')
Buggy code:
x, a, b = map(int, input().split())
print('delicious' if a >= b else 'safe' x >= b-a else 'dangerous')

Fixed code:
x, a, b = map(int, input().split())
if b - a > x:
    print('dangerous')
elif b > a:
    print('safe')
else:
    print('delicious')
Buggy code:
list = [int(i) for i in input().split()]

if list[1] >= list[2]:
    print("delicious")
elif list[1]+list[0] >= list[2]:
    print("safe")
else:
    print("dengerous")

Fixed code:
list = [int(i) for i in input().split()]

if list[1] >= list[2]:
    print("delicious")
elif list[1]+list[0] >= list[2]:
    print("safe")
else:
    print("dangerous")
Buggy code:
def main():
    t = list(map(int, input().split()))
    base = t[2] - t[1]
    ans = ''
    if t[0] > base:
        ans = 'delicious'
    elif t[0] == base:
        ans = 'safe'
    if t[0] < base:
        ans = 'dangerous'
    print(ans)

if __name__ == '__main__':
    main()

Fixed code:

def main():
    t = list(map(int, input().split()))
    ans = ''
    if t[1] >= t[2]:
        ans = 'delicious'
    elif t[0] >= t[2] - t[1]:
        ans = 'safe'
    if t[0] < t[2] - t[1]:
        ans = 'dangerous'
    print(ans)

if __name__ == '__main__':
    main()
Buggy code:
import sys
input = sys.stdin.readline
x,a,b=map(int,input().split())
if x-a+b<=0:
    print("delicious")
elif 0<x-a+b<=x:
    print("safe")
else:
    print("dangerous")


Fixed code:
import sys
input = sys.stdin.readline
x,a,b=map(int,input().split())
if -a+b<=0:
    print("delicious")
elif 0<-a+b<=x:
    print("safe")
else:
    print("dangerous")
Buggy code:
[a,b,c]=[int(x) for x in input().split()]

if b<c:
  print("delicious")
elif a+b<c:
  print("safe")
else:
  print("dangerous")

Fixed code:
[a,b,c]=[int(x) for x in input().split()]

if b>=c:
  print("delicious")
elif a+b>=c:
  print("safe")
else:
  print("dangerous")
Buggy code:
x,a,b = map(int, input().split())
if b <= a: print('delicious')
elif b-a <= x: print('safe')
else: print('dengerous')


Fixed code:
x,a,b = map(int, input().split())
if b <= a: print('delicious')
elif b-a <= x: print('safe')
else: print('dangerous')
Buggy code:
x,a,b=map(int,input().split());print([[['safe','dangerous'][b-a>x]],'delicious'][a-b<0])

Fixed code:
x,a,b=map(int,input().split());print(['delicious',['safe','dangerous'][b-a>x]][a-b<0])
Buggy code:
x, a, b = map(int, input().split())

z = a - b

if z > 0:
    print("delicious")
elif z*(-1) == x:
    print("safe")
else:
    print("dangerous")


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

z = a - b

if z >= 0:
    print("delicious")
elif z*(-1) <= x:
    print("safe")
else:
    print("dangerous")
Buggy code:
X,A,B = list(map(int,input().split()))
if A >= B:
    print("dericious")
elif B-A <= X:
    print("safe")
else:
    print("dangerous")

Fixed code:
X,A,B = list(map(int,input().split()))
if A >= B:
    print("delicious")
elif B-A <= X:
    print("safe")
else:
    print("dangerous")
Buggy code:
x,a,b=map(int,input().split())
print("delicious" if b-a<0 else 'safe' if b-a<x else 'dagerous')

Fixed code:
x,a,b=map(int,input().split())
print("delicious" if b-a<=0 else 'safe' if b-a<=x else 'dangerous')
Buggy code:
x,a,b = map(int,input().split())
if b <= a:
  print("delicious")
else:
  if a < b <= a + x:
    print("safe")
  else:
    print("dengerous")

Fixed code:
x,a,b = map(int,input().split())
if b <= a:
  print("delicious")
else:
  if a < b <= a + x:
    print("safe")
  else:
    print("dangerous")
Buggy code:
x,a,b = map(int,input().split())
if x < b :
    print("delicious")
elif x + a > b:
    print("safe")
else:
    print("dangerous")

Fixed code:
x, a, b = map(int,input().split())
if a >= b:
    print('delicious')
elif a + x < b:
    print('dangerous')
else:
    print('safe')
Buggy code:
x,a,b=map(int,input().split())
if b<=a:
    print("delicious")
else:
    pass=b-a
    if pass<=x:
        print("safe")
    else:
        print("dangerous")


Fixed code:
x,a,b=map(int,input().split())
pass_day=b-a
if b<=a:
    print("delicious")
else:
    if pass_day<=x:
        print("safe")
    else:
        print("dangerous")
Buggy code:
x, a, b = map(int, input().split())
if (a-b)>x:
  print('dangerous')
elif (a-b)>0:
  print('safe')
else:
  print('delicious')

Fixed code:
x,a,b = map(int,input().split())
d = b-a
if(d<=0):
	print("delicious")
elif(d>0):
	if(d<=x):
		print("safe")
	else:
		print("dangerous")
Buggy code:
import sys
input = sys.stdin.readline

X, A, B = [int(i) for i in input().split()]

if A >= B: print('delicious')
elif B - A >= X: print('safe')
else: print('dangerous')



Fixed code:
import sys
input = sys.stdin.readline

X, A, B = [int(i) for i in input().split()]

if A >= B: print('delicious')
elif B - A <= X: print('safe')
else: print('dangerous')
Buggy code:
x,a,b = map(int,input().split())
if a >= b:
    print('delicious')
elif b-a <= x:
    print('safe')
else:
    print('dengerous')

Fixed code:
x,a,b = map(int,input().split())
if a >= b:
    print('delicious')
elif b-a <= x:
    print('safe')
else:
    print('dangerous')
Buggy code:
X,A,B = map(int,input().split())
if B-A <= 0:
  print("delicious")
elif B-A >= X:
  print("safe")
else:
  print("dangerous")

Fixed code:
X,A,B = map(int,input().split())
if B-A <= 0:
  print("delicious")
elif B-A <= X:
  print("safe")
else:
  print("dangerous")
Buggy code:
a,b,c=map(int,input().split())
if d>c:
  print("delicious")
elif abs(b-c)>a:
  print("dangerous")
else:
  print("safe")

Fixed code:
a,b,c=map(int,input().split())
if b>=c:
  print("delicious")
elif abs(b-c)>a:
  print("dangerous")
else:
  print("safe")
Buggy code:
x,a,b=map(int,input().split())
if b-a=<0:
  print('delicious')
elif b-a=<x and not b-a=<0:
  print('safe')
else:
  print('dangerous')


Fixed code:
x,a,b=map(int,input().split())
if b-a <= 0:
    print('delicious')
elif b-a <= x and b-a >0:
    print('safe')
else:
    print('dangerous')
Buggy code:
a,b,c = map(int, input().split())
if c-d<=0:
  print("delicious")
elif c-d>0 and c-d<=x:
  print("safe")
elif c-d>0 and c-d>x:
  print("dangerous")

Fixed code:
a,b,c = map(int, input().split())
if c-b<=0:
  print("delicious")
elif c-b>0 and c-b<=a:
  print("safe")
elif c-b>0 and c-b>a:
  print("dangerous")
Buggy code:
x, a, b = map(int,input().split())
c = b - a
if c <= 0:
    print("delicious")
elif c < x:
    print("safe")
else:
    print("dengerous")

Fixed code:
x, a, b = map(int,input().split())
c = b - a
if c <= 0:
    print("delicious")
elif c <= x:
    print("safe")
else:
    print("dangerous")
Buggy code:
if(__name__=="__main__"):
    X, A, B =[int(i) for i in input().split()]
    #print(sum(a))
    
    if(A - B >= 0):
        print("delicious")
    elif(abs(A - B) <= X):
        print("safe")
    else:
        print("dengerous")

Fixed code:
if(__name__=="__main__"):
    X, A, B =[int(i) for i in input().split()]
    #print(sum(a))
    
    if(A - B >= 0):
        print("delicious")
    elif(abs(A - B) <= X):
        print("safe")
    else:
        print("dangerous")
Buggy code:
x,a,b=map(nt,input().split())
print("delicious" if a-b>=0 else "safe" if b-a<=x else "dangerous")

Fixed code:
x,a,b=map(int,input().split())
print("delicious" if a-b>=0 else "safe" if b-a<=x else "dangerous")
Buggy code:
import sys

stdin = sys.stdin

ri = lambda: int(rs())
rl = lambda: list(map(int, stdin.readline().split()))
rs = lambda: stdin.readline().rstrip()  # ignore trailing spaces

X, A, B = rl()
print('delicious' if A >= B else 'safe' if X >= A + B else 'dangerous')

Fixed code:
import sys

stdin = sys.stdin

ri = lambda: int(rs())
rl = lambda: list(map(int, stdin.readline().split()))
rs = lambda: stdin.readline().rstrip()  # ignore trailing spaces

X, A, B = rl()
print('delicious' if A >= B else 'safe' if X >= B - A else 'dangerous')
Buggy code:
a,b,c=map(int,input().split())
if b<c:
    if c-b>a:
        print("dangerous")
    else:
        print("safe")
else:
    print("delisious")

Fixed code:
a,b,c=map(int,input().split())
if b<c:
    if c-b>a:
        print("dangerous")
    else:
        print("safe")
else:
    print("delicious")
Buggy code:
x,a,b = map(int,input().split())

print('delicious') if b <= a else print('safe') if b < a+b else print('dangerous')

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

print('delicious') if b <= a else print('safe') if b <= a+x else print('dangerous')
Buggy code:
x, a, b = map(int, input().split())
print('delicious' if a-b>=0 else 'safe' a+x-b>=0 else 'dangerous')

Fixed code:
x, a, b = map(int, input().split())
print('delicious' if a-b>=0 else 'safe' if a+x-b>=0 else 'dangerous')
Buggy code:
x,a,c=map(int,input().split())
if -1*a+b <= 0:
  print('delicious')
elif -1*a+b <= x:
  print('safe')
else:print('dangerous')

Fixed code:
x,a,b=map(int,input().split())
if -1*a+b <= 0:
  print('delicious')
elif -1*a+b <= x:
  print('safe')
else:print('dangerous')
Buggy code:
x,a,b = map(int, input().split())
if b <= a:
  print('delicious')
elif b < a <= x :
  print('safe')
else:
  print('dangerous')

Fixed code:
x,a,b = map(int, input().split())
if b <= a:
  print('delicious')
elif a < b <= a+x:
  print('safe')
else:
  print('dangerous')
Buggy code:
X,A,B = map(int,input().split())

lim = -A+B
print(lim)

if lim<=0:
  print('delicious')
elif lim<=X:
  print('safe')
else:
  print('dangerous')


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

lim = -A+B
if lim<=0:
  print('delicious')
elif lim<=X:
  print('safe')
else:
  print('dangerous')
Buggy code:
x, a, b = map(int, input().split())
if a-b => 0 :
  print('delicious')
elif b-a <= x:
  print('safe')
else:
  print('dangerous')


Fixed code:
x,a,b=map(int,input().split())
if b-a <= 0:
  print("delicious")
elif b-a <= x:
  print("safe")
else:print("dangerous")
Buggy code:
x,a,b = map(int, input().split())
if b <= a:
  print('delicious')
elif b < a <= b+x :
  print('safe')
else:
  print('dangerous')


Fixed code:
x,a,b=map(int,input().split())
if b>x+a:
    print("dangerous")
elif x+a>=b>a:
    print("safe")
else:
    print("delicious")
Buggy code:
x, a, b = map(int, input().split())
if a <= b:
  print('delicious')
elif b - a >= x + 1:
  print('dangerous')
else:
  print('safe')
  

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


if x + a - b < 0:
  print('dangerous')
elif a - b >= 0:
  print("delicious")
else:
  print("safe")
Buggy code:
x,a,b = tuple(map(int,input().split()))
 
if b-a >=0 :
  print("delicious")
elif b-a<=x:
  print("safe")
else:
  print("dangerous")


Fixed code:
x, a, b = map(int,input().split())
if a-b >= 0:
    print("delicious")
elif a-b >= -x:
    print("safe")
else:
    print("dangerous")
Buggy code:
x,a,b=map(int,input().split())
if b>a and b-a<x:
	print("safe")
elif b=a and b-a=x:
	print("delicious")
elif b<a and a-b<x:
	print("delicious")
else:
	print("dangerous")
	


Fixed code:
x, a, b = map(int, input().split())
if a >= b:
  print("delicious")
elif x >= b-a:
  print("safe")
else:
  print("dangerous")
Buggy code:
x,a,b=map(int,input().split())
if b<=a:
  print('delicious')
elif b<=x:
  print("safe")
else:
  print("dangerous")

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

if 0 <= a - b:
    print("delicious")
elif b - a <= x:
    print("safe")
else:
    print("dangerous")
Buggy code:
X, A, B = list(map(int, input().split()))

if A > B:
    ans = 'delicious'
elif B - A <= X:
    ans = 'safe'
else:
    'dangerous'

print(ans)


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

if A - B >= 0:
  print('delicious')
elif B - A <= X:
  print('safe')
else:
  print('dangerous')
Buggy code:
input = input()
s_input = input.split()
print(s_input)
x = int(s_input[0]) * -1
a = int(s_input[1])
b = int(s_input[2])

kigenchouka = b - a

if kigenchouka > x:
    print("dangerous")
else:
    if kigenchouka <= 0:
        print("delicious")
    else:
        print("safe")


Fixed code:
input = input()
s_input = input.split()
x = int(s_input[0])
a = int(s_input[1])
b = int(s_input[2])

kigenchouka = b - a

if kigenchouka > x:
    print("dangerous")
else:
    if kigenchouka <= 0:
        print("delicious")
    else:
        print("safe")
Buggy code:
X,A,B = map (int,input().split())
if B-A <X:
  print('delicious')
elif B-A == X:
  print('safe')
else:
  print('dangerous')

Fixed code:
X,A,B = map (int,input().split())
if B <= A:
  print("delicious")
elif B <= A+X:
  print("safe")
else:
  print("dangerous")
Buggy code:
a,b,c = map(int,input().split())
print("delicious" if b=c else "safe" if c-b-1<=a else "dangerous")

Fixed code:
a,b,c = map(int,input().split())
print("delicious" if b>=c else "safe" if c-b-1<a else "dangerous")
Buggy code:
""" AtCoder """

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

if A >= B:
    print("delicious")
elif (A + X) < B:
    print("safe")
else:
    print("dangerous")


Fixed code:
""" AtCoder """

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

if A >= B:
    print("delicious")
elif (A + X) >= B:
    print("safe")
else:
    print("dangerous")
Buggy code:
# input
X, A, B = map(int, input().split())

if A - B < 0:
    print('dangerous')
elif A - B == 0:
    print('safe')
else:
    print('delicious')

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

if A >= B:
    print('delicious')
elif B - A <= X:
    print('safe')
else:
    print('dangerous')