qyliang/CodeNanoFix huggingface dataset:
Buggy code:
import math
x = int(input())
def lcm(x, y):
    return (x * y) // math.gcd(x, y)
if x == 1:
  print(360 / x)
elif x == 45:
  print(360 / x)
elif x == 90:
  print(360 / x)
else:
  z = lcm(x, 360)
  print(int(z / x))


Fixed code:
import math
x = int(input())
def lcm(x, y):
    return (x * y) // math.gcd(x, y)
if x == 1:
  print(int(360 / x))
elif x == 45:
  print(int(360 / x))
elif x == 90:
  print(int(360 / x))
else:
  z = lcm(x, 360)
  print(int(z / x))
Buggy code:
# -*- coding: utf-8 -*-
# get a integer
a = int(input())

m = a
c = 1
while m % 360 != 0:
	m+=a
	c+=1
print(m)

Fixed code:
# -*- coding: utf-8 -*-
# get a integer
a = int(input())

m = a
c = 1
while m % 360 != 0:
	m+=a
	c+=1
print(c)
Buggy code:
import math
x = int(input())
g = math.gcd(x,360)
print((x*360)//g)

Fixed code:
import math

x = int(input())
g = math.gcd(x,360)
print(360//g)
Buggy code:
x = int(input())
n = 0
while (x*n)%360!=0:
    n+=1
print(n)

Fixed code:
x = int(input())
n = 1
while (x*n)%360!=0:
    n+=1
print(n)
Buggy code:
import math
n=int(input())
print((n*360)//math.gcd(n,360))

Fixed code:
import math

n = int(input())

lcm = n * 360 // math.gcd(n, 360)
print(lcm // n)
Buggy code:
X=int(input())

ans=0
tmp=360    

if 360%X==0:
    ans=360/X
else:
    while(1):
        if tmp%X!=0:
            tmp+=360
        else:
            ans=tmp/X
            break
print(ans)

Fixed code:
X=int(input())

ans=0
tmp=360    

if 360%X==0:
    ans=360//X
else:
    while(1):
        if tmp%X!=0:
            tmp+=360
        else:
            ans=tmp//X
            break
print(ans)
Buggy code:
X = int(input())
ls = [2, 2, 2, 3, 3, 5]
a = []
for l in ls:
  if X % l == 0:
    a.append(l)
    X /= l
num = 1
if len(a) != 0:
  for b in a:
    num *= b
print(360 / b)

Fixed code:
X = int(input())
ls = [2, 2, 2, 3, 3, 5]
a = []
for l in ls:
  if X % l == 0:
    a.append(l)
    X /= l
num = 1
if len(a) != 0:
  for b in a:
    num *= b
print(int(360 / num))
Buggy code:
X=int(input())
B=0
C=0
for i in range(0,360):
    B=B+X
    C=B%360
    K=K+1
    if C==0:
        print(K)
        break
        
    
    

Fixed code:
X=int(input())
K=0
B=0
C=0
for i in range(0,360):
    B=B+X
    C=B%360
    K=K+1
    if C==0:
        print(K)
        break
Buggy code:
import math 
X = int(input())
lcm = 360 * X // math.gcd(360, X)
print(lcm)
K = lcm // X
print(K)

Fixed code:
import math
X = int(input())

lcm = (X * 360) // math.gcd(X, 360)
print(lcm//X)
Buggy code:
x=int(input())
import math
y=math.gcd(x,360)
print(y/x)

Fixed code:
import math
x = int(input())
y = math.gcd(x, 360)
print(int(360/y))
Buggy code:
import math
X = int(input())
g = math.gcd(360, X)
print(g // X)


Fixed code:
import math
X = int(input())
print(360 // math.gcd(X,360))
Buggy code:
import math

def lcm(x, y):
    return (x * y) // math.gcd(x, y)
  
x=int(input())
num=lcm(x,360)
print(num//360)


Fixed code:
import math

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

N = int(input())
print(lcm(N,360)//N)
Buggy code:
x = int(input())

ans =0

if 360 % x = 0:
  ans = 360 / x
else:
  i = 1
  while(True):
    i+=1
    if 360*i % x = 0:
      ans = 360*i /x
      break

print(ans)

Fixed code:
i = 1
x = int(input())
while True:
  if (360 * i) % x == 0:
    print(360 * i // x)
    break
  i += 1
Buggy code:
def main():
    X = int(input())

    for i in range(10**5):
        t += X
        if t % 360 == 0:
            return i + 1

print(main())


Fixed code:
def main():
    X = int(input())
    t = 0

    for i in range(10**5):
        t += X
        if t % 360 == 0:
            return i + 1

print(main())
Buggy code:
X = int(input())
i = 1
while True:
  if (360 * i) % X == 0:
    ans = (360 * i) / X
    break
  else:
    i += 1
print(ans)


Fixed code:
X = int(input())
i = 1
while True:
    if i*X%360 == 0:
        print(i)
        break
    else:
        i += 1
Buggy code:
x = int(input())
for i in range(1, 360):
    if (x*i)%360 == 0:
        print(i)
        exit()
        

Fixed code:
x = int(input())
for i in range(1, 10**5):
    if x*i%360==0:
        print(i)
        exit(0)
Buggy code:
import math
X = int(input())

ans = (X * 360) // math.gcd(X, 360)
print(ans)

Fixed code:

import math
X = int(input())

print ((X*360//math.gcd(X,360)) // X)
Buggy code:
from math import gcd
x = int(input())
print(360*gcd(x,360)//x)

Fixed code:
from math import gcd
x = int(input())
g = gcd(x,360)
print(((360//g)*(x//g)*g)//x)
Buggy code:
import math
x=int(input())
print((x*360)//math.gcd(x,360))

Fixed code:
import math
x=int(input())
num=360*x/math.gcd(360,x)
print(int(num//x))
Buggy code:
x =int(input())
for k in range(100000):
    if x*k%360==0:
        print(k)
        exit(0)

Fixed code:
x = int(input())

for k in range(1, 100000):
  if (k * x) % 360 == 0:
    print(k)
    exit()
Buggy code:
x = int(input())
for i in range(1, 361):
  if 360*i % x === 0:
    print(360*i//x)
    break
else:
  print(360)

Fixed code:
x = int(input())
for i in range(1, 361):
    if x * i % 360 == 0:
        print(i)
        break
Buggy code:
from math import gcd
print(360//gcd(360,int(input()))

Fixed code:
from math import gcd
print(360 //gcd(360, int(input())))
Buggy code:
from math import gcd
x=int(input())
g=gcd(x,360)
print(x//g)
  

Fixed code:
from math import gcd
g = gcd(int(input()), 360)
print(360 // g)
Buggy code:
from math import gcd
x = input()
print(360*gcd(x,360)//x)

Fixed code:
from math import gcd
x = int(input())
print((x * 360  // gcd(x, 360)) // x)
Buggy code:
X = int(input())
i = 1

while (360*i) % X != 0:
  i += 1
print(i)

Fixed code:
X = int(input())
i = 1
while (i*X) % 360 != 0:
    i += 1
print(i)
Buggy code:
x = int(input())
n = 360
for i in range(1,n):
  if (x*i)%360 == 0:
    print(i)
    exit()

Fixed code:
x = int(input())

for i in range(1, 1000):
    if x * i % 360 == 0:
        print(i)
        exit()
Buggy code:
A,V = map(int, input().split())
B,W = map(int, input().split())
T = int(input())

if abs(A-B) =< V*T-W*T:
  print('YES')
else:
  print('NO')

Fixed code:
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
if(V <= W):
  print('NO')
else:
  D = abs(A-B)
  X = V-W
  if(T*X < D):
    print('NO')
  else:
    print('YES')
Buggy code:
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
m = abs(a-b)
o = abs(v-w)
if a>b:
  if o*t>=m:
    print("YES")
  else:
    print("NO")
else:
  if o*t>=m:
    print("YES")
  else:
    print("NO")
  

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

if (v-w)*t>=abs(a-b):
    print("YES")
else:
    print("NO")
Buggy code:
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())

s = a+v*t
u = b+w*t
ss = a - v*t
uu = b - w*t
if s >= t or ss <= uu:
  print ('YES')
else:
  print ('NO')

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

s = a+v*t
u = b+w*t
ss = a - v*t
uu = b - w*t

if b >= a:
  if s >= u:
    print ('YES')
  else:
    print ('NO')
else:
  if ss <= uu:
    print ('YES')
  else:
    print ('NO')
Buggy code:
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if abs(b-a) - (v-w)*t <= 0:
    print("YES")
ekes:
    print("NO")

Fixed code:
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if abs(b-a) - (v-w)*t <= 0:
    print("YES")
else:
    print("NO")
Buggy code:
a,v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())

if(w>=v):
  print("NO")
else if(abs(b-a)/(v-w) > t):
  print("NO")
else:
  print("YES")


Fixed code:
a,v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
 
if(w>=v):
  print("NO")
elif(abs(b-a)/(v-w) > t):
  print("NO")
else:
  print("YES")
Buggy code:
A,V=map(int,(input().split()))
B,W=map(int,(input().split()))
T=int(input())
dist=abs(A-B)
sp=abs(V-W)
if(sp*T>=dist):
  print("YES")
else:
  print("NO")

Fixed code:
A,V=map(int,(input().split()))
B,W=map(int,(input().split()))
T=int(input())
dist=abs(A-B)
sp=V-W
if(sp*T>=dist):
  print("YES")
else:
  print("NO")
Buggy code:

inf = 10**18
mod = 10**9+7

a,v = map(int, input().split())
b,w = map(int, input().split())
t = int(input())
if v-w == 0:
    print('NO')
if t >= abs(a-b)/(v-w):
    print('YES')
else:
    print('NO')

Fixed code:
inf = 10**18
mod = 10**9+7

a,v = map(int, input().split())
b,w = map(int, input().split())
t = int(input())
if v-w <= 0:
    print('NO')
else:
    if t >= abs(a-b)/(v-w):
        print('YES')
    else:
        print('NO')
Buggy code:
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

a = V*T+A
b = W*T+B

if V >= W:
    if abs(A-B)/V-W <= T:
        print("YES")
    else:
        print("NO")
else:
    print("NO")

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

a = V*T+A
b = W*T+B

if V > W:
    if abs(A-B)/(V-W) <= T:
        print("YES")
    else:
        print("NO")
else:
    print("NO")
Buggy code:
A,V = (int(x) for x in input().split())
B,W = (int(x) for x in input().split())
T = int(input())
if V>W and (A-B)%(V-W)==0 and abs(A-B)//(V-M)<=T:
    Flag = True
else:
    Flag = False
    
if Flag:
    print('YES')
else:
    print('NO')

Fixed code:
A,V = (int(x) for x in input().split())
B,W = (int(x) for x in input().split())
T = int(input())

if V>W and abs(A-B)/(V-W)<=T:
    Flag = True
else:
    Flag = False
    
if Flag:
    print('YES')
else:
    print('NO')
Buggy code:
A, V = map(int,input().split())
B, W = map(int,input().split())
T = int(input())
if A >= B:
    if A + V * T >= B + W * T:
        print('YES')
    else:
        print('NO')
else:
    if V >= W:
        print('NO')
    elif A + V * T <= B + W * T:
        print('YES')
    else:
        print('NO')

Fixed code:
A, V = map(int,input().split())
B, W = map(int,input().split())
T = int(input())
if A <= B:
    if A + V * T >= B + W * T:
        print('YES')
    else:
        print('NO')
else:
    if A - V * T <= B -  W * T:
        print('YES')
    else:
        print('NO')
Buggy code:
import sys
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
if v<=w:
    print('NO')
    sys.exit()
else:
    d=abs(a-b)
    s=v-w
    if d<=ts:
        print('YES')
        sys.exit()
print('NO')

Fixed code:
import sys
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
if v<=w:
    print('NO')
    sys.exit()
else:
    d=abs(a-b)
    s=v-w
    if d<=t*s:
        print('YES')
        sys.exit()
print('NO')
Buggy code:
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
if (b-a)+t*v <= t*w:
    print("YES")
else:
    print("NO")

Fixed code:
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
if abs(b-a)+t*w <= t*v:
    print("YES")
else:
    print("NO")
Buggy code:
A,V = map(int,input().split())
B,W = map(int,input().split())
T=int(input())
if V<=W:
  print("NO")
elif abs(A-B)/(V-W)<=T:
  print("Yes")
else:
  print("NO")

Fixed code:
A,V = map(int,input().split())
B,W = map(int,input().split())
T=int(input())
if V<=W:
  print("NO")
elif abs(A-B)/abs(V-W)<=T:
  print("YES")
else:
  print("NO")
Buggy code:
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
if abs(v-w)*t >= abs(a-b):
  print('YES')
else:
  print('NO')

Fixed code:
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
l=abs(a-b)
if t*(v-w)>=l:
    print("YES")
else:
    print("NO")
Buggy code:
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())

dis = abs(a-b)
sub = w-v

if(-(sub*t)>=dis):
    print("YES")
else:

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

dis = abs(a-b)
sub = w-v

if(-(sub*t)>=dis):
    print("YES")
else:
    print("NO")
Buggy code:
a, v=map(int, input().split())
b, w=map(int, input().split())
t=int(input())

distance=abs(b-a)
speed=v-w

if speed<=0:
    print("NO")
else:
    if speed*t<=distance:
        print("YES")
    else:
        print("NO")

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

distance=abs(a-b)
speed=v-w

if speed<=0:
    print("NO")
else:
    if distance/speed <=t:
        print("YES")
    else:
        print("NO")
Buggy code:
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())


c=abs(a-b)+v*t-w*t
if c<=0:
    print("YES")
else:
    print("NO")

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


c=abs(a-b)-v*t+w*t
if c<=0:
    print("YES")
else:
    print("NO")
Buggy code:
import sys

a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())

d1 = v - w
d2 = abs(a-b) <= t*(v-w)
if d1 <= d2 :
    print("YES")
else:
    print('NO')

Fixed code:
import sys

a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())

d1 = (v - w)*t
d2 = abs(a-b) 
if v < w:
    print("NO")
elif d1 >= d2 :
    print("YES")
else:
    print('NO')
Buggy code:
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
 
if abs(b - a) <= abs(t*(w - v)): 
  print("YES")
else:
  print("NO")

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

ab = abs(a - b)
vw = v - w
if ab <= vw * t:
    print("YES")
else:
    print("NO")
Buggy code:
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())

if abs(A-B)/abs(W-V) > T:
    print('NO')
else:
    print('YES')

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

if W>=V or abs(A-B)/abs(W-V) > T:
    print('NO')
else:
    print('YES')
Buggy code:
A,V = map(int, input().split())
B,W = map(int, input().split())
T = int(input())

distance = abs(A-B)
speed = V - W

if speed != 0:
    if distance / speed <= T:
        print("YES")
    else:
        print("NO")
else:
    print("NO")

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

distance = abs(A-B)
speed = V - W

if speed > 0:
    if distance / speed <= T:
        print("YES")
    else:
        print("NO")
else:
    print("NO")
Buggy code:
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if v <= w:
    print('NO')
    exit()
if b - a >= t * (v - w):
    print('YES')
else:
    print('NO')

Fixed code:
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
if a<b:
    a+=v*t
    b+=w*t
    if a<b:
        print("NO")
    else:
        print("YES")
else:
    a-=v*t
    b-=w*t
    if a>b:
        print("NO")
    else:
        print("YES")
Buggy code:
a, v = map(int,input().split())
b, w = map(int,input().split())
t = int(input())
 
 
if abs(a-b) <= (v- w)*t:
    print('YES')
else:
    print('No')

Fixed code:
a, v = map(int,input().split())
b, w = map(int,input().split())
t = int(input())
 
 
if (abs(a-b) <= (v- w)*t):
    print('YES')
else:
    print('NO')
Buggy code:
a, v = map(int,input().split())
b, w = map(int,input().split())
t = int(input())
 
 
if (abs(a-b) == t*(v-w)):
    print("YES")
else:
    print("NO")

Fixed code:
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
print("YES" if abs(a-b) <= t*(v-w) else "NO")
Buggy code:
A, V = list(map(int, input().split()))
B, W = list(map(int, input().split()))
T = int(input())

kyori = max(A-B, B-A)

if W>V:
  print("NO")
else:
  if (W-V)*T>=kyori:
    print("YES")
  else:
    print("NO")

Fixed code:
A, V = list(map(int, input().split()))
B, W = list(map(int, input().split()))
T = int(input())

kyori = max(A-B, B-A)

if W>V:
  print("NO")
else:
  if (V-W)*T>=kyori:
    print("YES")
  else:
    print("NO")
Buggy code:
A,V=map(int,input().split())
B,W=map(int,input().split())
T=int(input())
X=abs(A-B)
Y=V-W
if X>=Y*T:
  print('YES')
else:
  print('NO')

Fixed code:
A,V=map(int,input().split())
B,W=map(int,input().split())
T=int(input())
X=abs(A-B)
Y=V-W
if X<=Y*T:
  print('YES')
else:
  print('NO')
Buggy code:
import io,sys
sys.setrecursionlimit(10**6)


def main():
    a,v = map(int,sys.stdin.readline().rstrip().split())
    b,w = map(int,sys.stdin.readline().rstrip().split())
    t = int(input())

    l = abs(a-b)
    p = abs(v-w)
    if p != 0 and l/p <= t:
        print("YES")
    else:
        print("NO")   
main()

Fixed code:
import io,sys
sys.setrecursionlimit(10**6)


def main():
    a,v = map(int,sys.stdin.readline().rstrip().split())
    b,w = map(int,sys.stdin.readline().rstrip().split())
    t = int(input())

    l = abs(a-b)
    p = v-w

    if p > 0 and l/p <= t:
        print("YES")
    else:
        print("NO") 
main()
Buggy code:
a, v = map(int,input().split())
b, w = map(int,input().split())
t=int(input())
if v<=w:
    print("NO")
else:
    time=abs(a-b)/(v-w)
    print(time)
    if time<=t:
        print("YES")
    else:
        print("NO")

Fixed code:
a, v = map(int,input().split())
b, w = map(int,input().split())
t=int(input())
if v<=w:
    print("NO")
else:
    time=abs(a-b)/(v-w)
    #print(time)
    if time<=t:
        print("YES")
    else:
        print("NO")
Buggy code:


l=list(map(int, input().split(' ')))
a=l[0]
v=l[1]
l=list(map(int, input().split(' ')))
b=l[0]
w=l[1]
s=int(input())
ans=True
if a>b:
    ans=a-v*s<=b-w*s
else:
    ans=a+v*s<=b+w*s
if ans:
    print("YES")
else:
    print("NO")
    



Fixed code:

l=list(map(int, input().split(' ')))
a=l[0]
v=l[1]
l=list(map(int, input().split(' ')))
b=l[0]
w=l[1]
s=int(input())
ans=True
if a>b:
    ans=a-v*s<=b-w*s
else:
    ans=a+v*s>=b+w*s
if ans:
    print("YES")
else:
    print("NO")
Buggy code:
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())

if abs(b-a)<= abs(v-w)*t:
    print ("YES")
else:
    print("NO")


Fixed code:
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if w>=v:
    print("NO")
elif abs(a-b) <= t*(v-w):
    print("YES")
else:
    print("NO")
Buggy code:
A_V = input().split(" ")
B_W = input().split(" ")
T = int(input())
A = int(A_V[0])
V = int(A_V[1])
B = int(B_W[0])
W = int(B_W[1])
dA = A + V * T
dB = B + W * T
ndA = A - V * T
ndB = B - W * T
if (dA < dB):
    if (ndA > ndB)
        print("NO")
    else:
        print("YES")

Fixed code:
A_V = input().split(" ")
B_W = input().split(" ")
T = int(input())
A = int(A_V[0])
V = int(A_V[1])
B = int(B_W[0])
W = int(B_W[1])
dA = A + V * T
dB = B + W * T
ndA = A - V * T
ndB = B - W * T
if (A<B):
    if (dA < dB):
        print("NO")
    else:
        print("YES")
else:
    if (ndA > ndB):
        print("NO")
    else:
        print("YES")
Buggy code:
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

A_sum = A + V * T
B_sum = B + W * T

if B > A:
    if A_sum >= B_sum:
        print('YES')
    else:
        print('NO')

else:
    if A_sum <= B_sum
        print('YES')
    else:
        print('NO')


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


if A < B:
    A_sum = A + (V * T)
    B_sum = B + (W * T)
    if A_sum >= B_sum:
        print('YES')
    else:
        print('NO')

else:
    A_sum = A - (V * T)
    B_sum = B - (W * T)
    if A_sum <= B_sum:
        print('YES')
    else:
        print('NO')
Buggy code:
A,V=map(int,input().split())
B,W=map(int,input().split())
T=int(input())
if A+T*V >= B+T*W:
  print("YES")
elif  A-T*V <= B-T*W:
  print("YES")
else:
  print("NO")

Fixed code:
A,V=map(int,input().split())
B,W=map(int,input().split())
T=int(input())
if A <= B and A+T*V >= B+T*W:
  print("YES")
elif A >=B and A-T*V <= B-T*W:
  print("YES")
else:
  print("NO")
Buggy code:
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())

if abs(A-B) <= abs(V-W)*T:
  print("YES")
else:
  print("NO")

Fixed code:
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())
 
if abs(A-B) <= abs(V-W)*T and V > W :
  print("YES")
else:
  print("NO")
Buggy code:
a,v=map(int, input().split())
b,w=map(int, input().split())
t = int(input())
x = abs(b-a)
y = (w-v)*t
if(x>=y):
    print("YES")
else:
    print("NO")

Fixed code:
a,v=map(int,input().split())
b,w=map(int,input().split())
t=int(input())
if t*(v-w)>=abs(a-b):
	print("YES")
else:
	print("NO")
Buggy code:
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())

if a = b:
  print('YES')
elif a < b:
  if b - w * t <= a - v * t:
    print('YES')
  else:
    print('NO')
else:
  if a + v * t <= b + w * t:
    print('YES')
  else:
	  print('NO')
  


Fixed code:
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if a < b:
  if a + t * v >= b + t * w:
    print('YES')
  else:
    print('NO')
else:
  if a - t * v <= b - t * w:
    print('YES')
  else:
    print('NO')
Buggy code:
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if (b-a) < t*(w-v):
  print('YES')
else:
  print('NO')

Fixed code:
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if abs(a-b) <= t*(v-w):
  print('YES')
else:
  print('NO')
Buggy code:
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
if v*t >= abs(b-a) + W*t:
    print('YES')
else:
    print('NO')

Fixed code:
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
if v*t >= abs(b-a) + w*t:
    print('YES')
else:
    print('NO')
Buggy code:
A,V = map(int,input().split())
B,W= map(int,input().split())
T = int(input()
dist = abs(A-B)
vec = V-W
print('Yes' if vec*T >= dist else 'NO')

Fixed code:
A,V = map(int,input().split())
B,W= map(int,input().split())
T = int(input())
dist = abs(A-B)
vec = V-W
print('YES' if vec*T >= dist else 'NO')
Buggy code:
a, v= map(int, input().split())
b, w= map(int, input().split())
t = int(input())
l = b-a
s = v-w

    print('YES' if l<=s*t else 'NO')


Fixed code:
a, v= map(int, input().split())
b, w= map(int, input().split())
t = int(input())
l = abs(b-a)
s = v-w
print('YES' if l<=s*t else 'NO')
Buggy code:
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
if(V > W):
    print("NO")
elif(abs(A-B)>T*(W-V)):
    print("NO")
else:
    print("YES")

Fixed code:
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
if(V<W):
    print("NO")
elif(abs(A-B)>T*(V-W)):
    print("NO")
else:
    print("YES")
Buggy code:
import numpy as np

A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

if V <= W: print("NO")
elif: np.abs(A-B)/(V-W) <= T: print("YES")
else: print("NO")

Fixed code:
import numpy as np

A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())

if V <= W:
    print("NO")
elif np.abs(A - B) / (V - W) <= T: print("YES")
else:
    print("NO")
Buggy code:
a, v = map(int,input().split())
b, w = map(int,input().split())
T = int(input())

if a<b:
    A = a + v * T
    B = b + w * T
    if A>= B:
        print("Yes")
    else:
        print("NO")
else:
    A = a - v*T
    B = b - w * T
    if A <= B:
        print("Yes")
    else:
        print("NO")



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

if a<b:
    A = a + v * T
    B = b + w * T
    if A>= B:
        print("YES")
    else:
        print("NO")
else:
    A = a - v*T
    B = b - w * T
    if A <= B:
        print("YES")
    else:
        print("NO")
Buggy code:
A,V = [int(i) for i in input().split()]
B,W = [int(i) for i in input().split()]
T = int(input())

if A+V*T >= B+W*T or A-V*T <= B-W*T:
    print('YES')
else:
    print('NO')


Fixed code:
A,V = [int(i) for i in input().split()]
B,W = [int(i) for i in input().split()]
T = int(input())

if A < B:
    if A+V*T >= B+W*T:
        print('YES')
    else:
        print('NO')
else:
    if A-V*T <= B-W*T:
        print('YES')
    else:
        print('NO')