problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k | fixed_code stringlengths 12 526k | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M | fixed_submission_id int64 2 1.54M | user_id stringlengths 10 10 | language stringclasses 8
values |
|---|---|---|---|---|---|---|---|
p02696 | a=list(map(int, input().split()))
A=a[0]
B=a[1]
N=a[2]
if B<N:
i=int(A*(B-1)/B)-A*int((B-1)/B)
else:
i=int(A*N/B)-A*int(N/B)
print(i) | a=list(map(int, input().split()))
A=a[0]
B=a[1]
N=a[2]
if B-1<N:
i=int(A*(B-1)/B)-A*int((B-1)/B)
else:
i=int(A*N/B)-A*int(N/B)
print(i) | [
"control_flow.branch.if.condition.change"
] | 444,042 | 444,043 | u386944085 | python |
p02696 | a,b,n = map(int,input().split())
x = b-1
if b > n:
res = int(a/b)
else :
res = int((a/b)*(b-1))
print(res)
| a,b,n = map(int,input().split())
x = b-1
if b > n:
res = int((a/b)*n)
else :
res = int((a/b)*(b-1))
print(res)
| [
"call.arguments.change",
"call.arguments.add"
] | 444,044 | 444,045 | u891945807 | python |
p02696 | import math
A,B,N = map(int,input().split())
if B-1>N:
print(math.floor((A*N)/B)-A*math.floor(N/B))
else:
print(math.floor((A*B-1)/B)-A*math.floor(B-1/B)) | import math
A,B,N = map(int,input().split())
if B-1>N:
print(math.floor((A*N)/B)-A*math.floor(N/B))
else:
print(math.floor((A*(B-1))/B)-A*math.floor((B-1)/B)) | [
"call.arguments.change"
] | 444,052 | 444,053 | u005317312 | python |
p02696 | a,b,n = map(int,input().split())
x = math.floor(a*n/b)-( a*math.floor(n/b))
y = math.floor(a*b/b)-( a*math.floor(b/b))
z = math.floor(a*(b-1)/b)-( a*math.floor((b-1)/b))
if b == 1:
print(0)
elif n < b:
print(x)
else:
print(z) | import math
a,b,n = map(int,input().split())
x = math.floor(a*n/b)-( a*math.floor(n/b))
y = math.floor(a*b/b)-( a*math.floor(b/b))
z = math.floor(a*(b-1)/b)-( a*math.floor((b-1)/b))
if b == 1:
print(0)
elif n < b:
print(x)
else:
print(z) | [] | 444,056 | 444,057 | u491762407 | python |
p02696 | A,B,N = map(int,input().split())
if N > B:
print(int(A*(B-1)/B) - A * int((B-1)/B))
else:
print(int(A*N/B) - A*int(N/B)) | A,B,N = map(int,input().split())
if N >= B:
print(int(A*(B-1)/B) - A * int((B-1)/B))
else:
print(int(A*N/B) - A*int(N/B)) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,060 | 444,061 | u895408600 | python |
p02696 | import math
a, b, n = [int(i) for i in input().split(' ')]
if n > b:
x = b - 1
else:
x = n
f = math.floor(a * x / b) - a * math.floor(x / b)
print(f) | import math
a, b, n = [int(i) for i in input().split(' ')]
if n >= b:
x = b - 1
else:
x = n
f = math.floor(a * x / b) - a * math.floor(x / b)
print(f) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,066 | 444,067 | u203597140 | python |
p02696 | a,b,n=map(int,input().split())
def f(x,a=a,b=b):
return (a*x//b) -a*(x//b)
print(f(b-1) if b<n else f(n)) | a,b,n=map(int,input().split())
def f(x,a=a,b=b):
return (a*x//b) -a*(x//b)
print(f(b-1) if b<=n else f(n)) | [
"expression.operator.compare.change",
"call.arguments.change",
"io.output.change"
] | 444,068 | 444,069 | u450983668 | python |
p02696 | #!/usr/bin/env python3
import sys
import math
# from decimal import *
from fractions import *
def solve(A: int, B: int, N: int):
def kansuu(x):
# return math.floor(A*x/B) - A * math.floor(x/B)
left = math.floor(Fraction(A) * Fraction(x) * Fraction(1, B))
right = Fraction(A) * math.floor(Fr... | #!/usr/bin/env python3
import sys
import math
# from decimal import *
from fractions import *
def solve(A: int, B: int, N: int):
def kansuu(x):
# return math.floor(A*x/B) - A * math.floor(x/B)
left = math.floor(Fraction(A) * Fraction(x) * Fraction(1, B))
right = Fraction(A) * math.floor(Fr... | [
"call.remove"
] | 444,084 | 444,085 | u328099989 | python |
p02696 | # Problem D - Floor Function
import math
# input
A, B, N = map(int, input().split())
# initialization
ans = 0
if N<=B:
ans = math.floor(A*N/B) - A * math.floor(N/B)
else:
ans = math.floor(A*(B-1)/B) - A * math.floor((B-1)/B)
# output
print(ans)
| # Problem D - Floor Function
import math
# input
A, B, N = map(int, input().split())
# initialization
ans = 0
if N<B:
ans = math.floor(A*N/B) - A * math.floor(N/B)
else:
ans = math.floor(A*(B-1)/B) - A * math.floor((B-1)/B)
# output
print(ans)
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,090 | 444,091 | u368249389 | python |
p02696 | import math
A, B, N = map(int, input().split())
solved_flag = False
if B==1:
ans = 0
solved_flag = True
else:
if B < N:
x = B-1
else:
x = N
if not solved_flag:
ans = math.floor(A*x/B) - A*math.floor(x/B)
print(ans) | import math
A, B, N = map(int, input().split())
solved_flag = False
if B==1:
ans = 0
solved_flag = True
else:
if B <= N:
x = B-1
else:
x = N
if not solved_flag:
ans = math.floor(A*x/B) - A*math.floor(x/B)
print(ans) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,094 | 444,095 | u531220228 | python |
p02696 | import math
A, B, N = list(map(int, input().split()))
if B >= N:
ans = int(A*(N/B-N//B))
else:
ans = int(A*(B-1)/B)
print(ans) | import math
A, B, N = list(map(int, input().split()))
if B > N:
ans = int(A*(N/B-N//B))
else:
ans = int(A*(B-1)/B)
print(ans) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,106 | 444,107 | u991134049 | python |
p02696 | import math
s = list(map(int,input().split()))
a = s[0]
b = s[1]
n = s[2]
x = 0
if b-1 <= n:
x = b-1
ans = math.floor(a*x/b)-n*math.floor(x/b)
else:
x = n-1
ans = math.floor(a*x/b)-n*math.floor(x/b)
print(ans) | import math
s = list(map(int,input().split()))
a = s[0]
b = s[1]
n = s[2]
x = 0
if b-1 <= n:
x = b-1
ans = math.floor(a*x/b)-n*math.floor(x/b)
else:
x = n
ans = math.floor(a*x/b)-n*math.floor(x/b)
print(ans) | [
"expression.operation.binary.remove"
] | 444,108 | 444,109 | u245960901 | python |
p02696 | a, b, n = map(int, input().split())
if b<n:
i = b-1
ans = (a*i//b) - a*(i//b)
else:
i = n
ans = (a*i//b) - a*(i//b)
# ans = [(a*i//b) - a*(i//b) for i in range(1, min(b, n)+1)]
# print(max(ans))
print(ans)
| a, b, n = map(int, input().split())
if b<=n:
i = b-1
ans = (a*i//b) - a*(i//b)
else:
i = n
ans = (a*i//b) - a*(i//b)
print(ans)
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,112 | 444,113 | u072949274 | python |
p02696 | A, B, N = map(int, input().split())
if (N <= B):
print(((A * (N)) // B) - (A * ((N) // B)))
elif(N > B):
print(((A * (B - 1)) // B) - (A * ((B - 1) // B)))
| A, B, N = map(int, input().split())
if (N < B):
print(((A * (N)) // B) - (A * ((N) // B)))
elif(N >= B):
print(((A * (B - 1)) // B) - (A * ((B - 1) // B)))
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,118 | 444,119 | u787059958 | python |
p02696 | a, b, n = map(int, input().split())
ans1 = -111111
if n > b:
ans1 = (a * (b-1))//b - a*((b-1)//b)
ans2 = (a * n)//b - a*(n//b)
print(max(ans1, ans2)) | a, b, n = map(int, input().split())
ans1 = -111111
if n >= b:
ans1 = (a * (b-1))//b - a*((b-1)//b)
ans2 = (a * n)//b - a*(n//b)
print(max(ans1, ans2)) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,122 | 444,123 | u136869985 | python |
p02696 | import math
A,B,N=map(int,input().split())
result=0
if B<=N:
x=(N//B)*B-1
result=math.floor(A*x/B)-A*math.floor(N/B)
if B>N:
result=math.floor(A*N/B)-A*math.floor(N/B)
if B==1:
print(0)
else:
print(result)
| import math
A,B,N=map(int,input().split())
result=0
if B<=N:
x=(N//B)*B-1
result=math.floor(A*x/B)-A*math.floor(x/B)
if B>N:
result=math.floor(A*N/B)-A*math.floor(N/B)
if B==1:
print(0)
else:
print(result)
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 444,128 | 444,129 | u804850951 | python |
p02696 | #!/usr/bin/env python3
import math
a, b, n = map(int, input().split())
if n > b:
print(math.floor((a * (b - 1)) / b) - a * math.floor((b - 1) / b))
else:
print(math.floor((a * n / b) - a * math.floor(n / b))) | #!/usr/bin/env python3
import math
a, b, n = map(int, input().split())
if n >= b:
print(math.floor((a * (b - 1)) / b) - a * math.floor((b - 1) / b))
else:
print(math.floor((a * n / b) - a * math.floor(n / b))) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,157 | 444,158 | u536560967 | python |
p02696 | import math
A,B,N = map(int, input().split())
if B < N:
print(math.floor( (A*(B-1))/B ))
else:
print(math.floor( (A*N)/B )) | import math
A,B,N = map(int, input().split())
if B <= N:
print(math.floor( (A*(B-1))/B ))
else:
print(math.floor( (A*N)/B )) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,177 | 444,178 | u697559326 | python |
p02696 | from math import floor
A,B,N = map(int, input().split())
m = A//B
a = A%B
x = max(N,B-1)
print(m*x+floor(a*x/B)) | from math import floor
A,B,N = map(int, input().split())
m = A//B
a = A%B
x = min(N,B-1)
print(m*x+floor(a*x/B)) | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 444,183 | 444,184 | u476604182 | python |
p02696 | from math import floor
A,B,N = map(int, input().split())
m = A//B
a = A%B
x = N%B
print(m*x+floor(a*x/B)) | from math import floor
A,B,N = map(int, input().split())
m = A//B
a = A%B
x = min(N,B-1)
print(m*x+floor(a*x/B)) | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 444,185 | 444,184 | u476604182 | python |
p02696 | A,B,N=map(int,input().split())
if B<=N:
print(A*(B-1)/B)
else:
print(int(A*N/B))
| A,B,N=map(int,input().split())
if B<=N:
print(int(A*(B-1)/B))
else:
print(int(A*N/B))
| [
"call.arguments.add",
"call.arguments.change"
] | 444,186 | 444,187 | u428199834 | python |
p02696 | import math
A, B, N = map(int, input().split())
if B - 1 <= N:
x = B - 1
else:
x = N
print('h')
ans = math.floor(A * x / B) - A * math.floor(x / B)
print(ans)
| import math
A, B, N = map(int, input().split())
if B - 1 <= N:
x = B - 1
else:
x = N
ans = math.floor(A * x / B) - A * math.floor(x / B)
print(ans)
| [
"call.remove"
] | 444,188 | 444,189 | u815878613 | python |
p02696 | import math
A,B,N = map(int,input().split())
m = min(B,N)
num = math.floor((A*m)/B) - A * math.floor(m / B)
print(num) | import math
A,B,N = map(int,input().split())
m = min(B-1,N)
num = math.floor((A*m)/B) - A * math.floor(m / B)
print(num) | [
"assignment.change"
] | 444,195 | 444,196 | u198930868 | python |
p02696 | A,B,N = map(int,input().split())
if N<= B-1:
ans = (N*A)//B
else:
((B-1)*A)//B
print(ans) | A,B,N = map(int,input().split())
if N<= B-1:
ans = (N*A)//B
else:
ans = ((B-1)*A)//B
print(ans) | [
"assignment.add"
] | 444,203 | 444,204 | u679520304 | python |
p02696 | import math
def f(a, b, x):
return math.floor(a*x/b) - 5 * math.floor(x/b)
a, b, n = map(int, input().split())
max = 0
if b < n:
print(f(a, b, b-1))
else:
print(f(a, b, n)) | import math
def f(a, b, x):
return math.floor(a*x/b) - 5 * math.floor(x/b)
a, b, n = map(int, input().split())
max = 0
if b <= n:
print(f(a, b, b-1))
else:
print(f(a, b, n)) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,218 | 444,219 | u819407764 | python |
p02696 | import math
A, B, N = map(int, input().split())
left = -1
right = N
def check(x):
global A, B
return math.floor(A * x / B) - A * math.floor(x / B)
if B == N:
print(check(N - 1))
else:
print(check(N))
| import math
A, B, N = map(int, input().split())
left = -1
right = N
def check(x):
global A, B
return math.floor(A * x / B) - A * math.floor(x / B)
if B <= N:
print(check(B - 1))
else:
print(check(N))
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 444,234 | 444,235 | u463858127 | python |
p02696 | s = list(map(int, input().split()))
a = s[0]
b = s[1]
n = s[2]
if n % b == 0:
n = n - 1
kotae = round(a * ((n / b) - (n // b)) - ((a * n / b) - ((a * n) // b)))
print(kotae) | s = list(map(int, input().split()))
a = s[0]
b = s[1]
n = s[2]
if n >= b:
n = b - 1
kotae = round(a * ((n / b) - (n // b)) - ((a * n / b) - ((a * n) // b)))
print(kotae) | [
"control_flow.branch.if.condition.change",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 444,242 | 444,243 | u044635590 | python |
p02696 | a, b, n = map(int, input().split())
print(math.floor(a * min((b - 1), n) / b)) | import math
a, b, n = map(int, input().split())
print(math.floor(a * min((b - 1), n) / b)) | [] | 444,246 | 444,247 | u091051505 | python |
p02696 | a,b,n=map(int,input().split())
if (n<=b):
print(a*n//b)
else:
print(a*(b-1)//b) | a,b,n=map(int,input().split())
if (n<b):
print(a*n//b)
else:
print(a*(b-1)//b) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,252 | 444,253 | u286754585 | python |
p02696 | import math
A, B, N = map(int, input().split())
if N // B == 0:
f, _ = math.modf(N / B)
ans = math.floor(A * f)
else:
n = (N // B) * B - 1
f1, _ = math.modf(n)
f2, _ = math.modf(N / B)
f = max(f1, f2)
ans = math.floor(A * f)
print(ans) | import math
A, B, N = map(int, input().split())
if N // B == 0:
f, _ = math.modf(N / B)
ans = math.floor(A * f)
else:
n = (N // B) * B - 1
f1, _ = math.modf(n / B)
f2, _ = math.modf(N / B)
f = max(f1, f2)
ans = math.floor(A * f)
print(ans) | [
"assignment.change"
] | 444,270 | 444,271 | u616169109 | python |
p02696 | import math
a,b,n=map(int, input().split())
x=n%b
if n==0:
print(0)
else:
if x==0:
x=b-1
num1=math.floor((a*x)/b)
num2=a*math.floor(x/b)
print(num1-num2) | import math
a,b,n=map(int, input().split())
x=n%b
if n==0:
print(0)
else:
if x==0 or n>=b:
x=b-1
num1=math.floor((a*x)/b)
num2=a*math.floor(x/b)
print(num1-num2) | [
"control_flow.branch.if.condition.change"
] | 444,276 | 444,277 | u549474450 | python |
p02696 | a, b, n = map(int, input().split())
if n > b:
print((a * (b-1)) // b)
else:
print((a * n) // b)
| a, b, n = map(int, input().split())
if n >= b-1:
print((a * (b-1)) // b)
else:
print((a * n) // b)
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,280 | 444,281 | u970002663 | python |
p02696 | a,b,n = map(int,input().split())
m = 0
x = n
if b < n:x = b-1
print((a*x//b)) | a,b,n = map(int,input().split())
m = 0
x = n
if b <= n:x = b-1
print((a*x//b)) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,313 | 444,314 | u785578220 | python |
p02696 | a, b, n = map(int, input().split())
if b == 1:
print(n)
exit()
if b - 1 <= n:
print((a * (b - 1) // b) - a * ((b - 1) // b))
exit()
print((a * n // b) - a * (n // b)) | a, b, n = map(int, input().split())
if b == 1:
print(0)
exit()
if b - 1 <= n:
print((a * (b - 1) // b) - a * ((b - 1) // b))
exit()
print((a * n // b) - a * (n // b)) | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"io.output.change"
] | 444,320 | 444,321 | u377989038 | python |
p02696 | # D - Floor Function
A, B, N = map(int, input().split())
X = min(B, N)
print((A*X)//B - A*(X//B))
| # D - Floor Function
A, B, N = map(int, input().split())
X = min(B-1, N)
print((A*X)//B - A*(X//B))
| [
"assignment.change"
] | 444,338 | 444,339 | u141786930 | python |
p02696 | #int(input())
#map(int,input().split())
#list(map(int,input().split()))
a,b,n=map(int,input().split())
l=[]
if n>=b:
x=b-1
else:
x=n
print(math.floor((a*x)/b)-a*math.floor(x/b)) | #int(input())
#map(int,input().split())
#list(map(int,input().split()))
import math
a,b,n=map(int,input().split())
l=[]
if n>=b:
x=b-1
else:
x=n
print(math.floor((a*x)/b)-a*math.floor(x/b)) | [] | 444,380 | 444,381 | u338738170 | python |
p02696 | A,B,N=map(int,input().split())
x=min(A-1,N)
print(int(A*x/B)-A*int(x/B)) | A,B,N=map(int,input().split())
x=min(B-1,N)
print(int(A*x/B)-A*int(x/B)) | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 444,390 | 444,391 | u970449052 | python |
p02696 | import sys
import math as mt
import collections as cc
I=lambda:list(map(int,input().split()))
a,b,n=I()
ans=0
temp=min(n,b)
print(mt.floor((a*temp)/b))
| import sys
import math as mt
import collections as cc
I=lambda:list(map(int,input().split()))
a,b,n=I()
ans=0
temp=min(n,b-1)
print(mt.floor((a*temp)/b))
| [
"assignment.change"
] | 444,394 | 444,395 | u995109095 | python |
p02696 | def main():
a,b,n = map(int,input().split())
if b>n:
print(int(a*(n/b-n//b)))
else:
print(int(a*(1/b)))
if __name__ == "__main__":
main() | def main():
a,b,n = map(int,input().split())
if b>n:
print(int(a*(n/b-n//b)))
else:
print(int(a*((b-1)/b)))
if __name__ == "__main__":
main() | [
"call.arguments.change"
] | 444,400 | 444,399 | u546338822 | python |
p02696 | def main():
a,b,n = map(int,input().split())
if b>=n:
print(int(a*(n/b-n//b)))
else:
print(int(a*(1/b)))
if __name__ == "__main__":
main() | def main():
a,b,n = map(int,input().split())
if b>n:
print(int(a*(n/b-n//b)))
else:
print(int(a*((b-1)/b)))
if __name__ == "__main__":
main() | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"call.arguments.change"
] | 444,401 | 444,399 | u546338822 | python |
p02696 | a,b,n = map(int,input().split())
if(b < n):
print((a*(b-1))//b)
else:
print((a*n)//b-a*(n//b)) | a,b,n = map(int,input().split())
if(b < n+2):
print((a*(b-1))//b)
else:
print((a*n)//b-a*(n//b)) | [
"control_flow.branch.if.condition.change"
] | 444,406 | 444,407 | u289036437 | python |
p02696 | import math
A,B,N = map(int,input().split())
if N < B:
x = N
elif N == B:
x = N
elif N > B:
x = B - 1
s = x / B - x // B
print(math.floor(A * s)) | import math
A,B,N = map(int,input().split())
if N < B:
x = N
elif N == B:
x = B - 1
elif N > B:
x = B - 1
s = x / B - x // B
print(math.floor(A * s)) | [
"assignment.value.change"
] | 444,408 | 444,409 | u195355592 | python |
p02696 | A, B, N = map(int, input().split())
if N <= B:
print((A*(N))//B - A*((N)//B))
else:
print((A*(B-1))//B - A*((B-1)//B)) | A, B, N = map(int, input().split())
if N < B:
print((A*(N))//B - A*((N)//B))
else:
print((A*(B-1))//B - A*((B-1)//B)) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,436 | 444,437 | u306516971 | python |
p02696 | a, b, n = map(int, input().split())
if b == 1:
print(0)
else:
x = min(b-1, n)
print(floor(a*x/b) - a * floor(x/b)) | from math import floor
a, b, n = map(int, input().split())
if b == 1:
print(0)
else:
x = min(b-1, n)
print(floor(a*x/b) - a * floor(x/b)) | [] | 444,440 | 444,441 | u693974737 | python |
p02696 | import math
ABN = list(map(int, input().split()))
#xがBの倍数であれば全体が0
#その一個手前が最大値
if (ABN[2] > ABN[1]):
print(math.floor(ABN[0] * (ABN[1] - 1) / ABN[1]))
else:
print(math.floor(ABN[0] * ABN[2] / ABN[1]) - ABN[0] * math.floor(ABN[2] / ABN[1])) | import math
ABN = list(map(int, input().split()))
#xがBの倍数であれば全体が0
#その一個手前が最大値
if (ABN[2] >= ABN[1]):
print(math.floor(ABN[0] * (ABN[1] - 1) / ABN[1]))
else:
print(math.floor(ABN[0] * ABN[2] / ABN[1]) - ABN[0] * math.floor(ABN[2] / ABN[1])) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,463 | 444,464 | u995323427 | python |
p02696 | [A,B,N] = [int(s) for s in input().rstrip().split(' ')]
if B == 1:
print(0)
elif N <= B:
print(A*N//B)
else:
print((A*(B-1))//B) | [A,B,N] = [int(s) for s in input().rstrip().split(' ')]
if B == 1:
print(0)
elif N < B:
print(A*N//B)
else:
print((A*(B-1))//B) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,469 | 444,470 | u267035391 | python |
p02696 | from math import floor
def main():
a, b, n = map(float, input().split())
if n < b:
x = n
else:
x = b
ans = floor(a * x/b) - a * floor(x/b)
print(int(ans))
if __name__ == "__main__":
main()
| from math import floor
def main():
a, b, n = map(float, input().split())
if n < b:
x = n
else:
x = b - 1
ans = floor(a * x/b) - a * floor(x/b)
print(int(ans))
if __name__ == "__main__":
main()
| [
"assignment.change"
] | 444,516 | 444,517 | u426649993 | python |
p02696 | a,b,n = map(int, input().split())
if n < b:
print(math.floor(a*n/b) - a*math.floor(n/b))
else:
print(math.floor(a * (b-1) / b) - a * math.floor((b-1) / b))
| import math
a,b,n = map(int, input().split())
if n < b:
print(math.floor(a*n/b) - a*math.floor(n/b))
else:
print(math.floor(a * (b-1) / b) - a * math.floor((b-1) / b)) | [] | 444,522 | 444,523 | u390193191 | python |
p02696 | import sys
input = sys.stdin.readline
A, B, N = map(int, input().split())
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
ps = ... | import sys
input = sys.stdin.readline
A, B, N = map(int, input().split())
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
ps = ... | [
"control_flow.branch.if.add"
] | 444,526 | 444,527 | u141610915 | python |
p02696 | a, b, n = map(int, input().split())
if n >= b:
x = b - 7
else:
x = n
d1 = a*x // b
d2 = x // b
res = d1 - (a * d2)
print(res) | a, b, n = map(int, input().split())
if n >= b:
x = b - 1
else:
x = n
d1 = a*x // b
d2 = x // b
res = d1 - (a * d2)
print(res) | [
"literal.number.integer.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 444,530 | 444,531 | u073549161 | python |
p02696 | A, B, N = map(int,input().split())
if N >= B: print(A * (B - 1) // B - A * (B - 1) // B)
else: print(A * N // B - A * (N // B))
| A, B, N = map(int,input().split())
if N >= B - 1: print(A * (B - 1) // B - A * ((B - 1) // B))
else: print(A * N // B - A * (N // B))
| [
"control_flow.branch.if.condition.change",
"call.arguments.change"
] | 444,534 | 444,535 | u460185449 | python |
p02696 | A, B, N = map(int, input().split())
if N < B:
ans = A * N // B - N // B * A
else:
ans = A * (B-1) // B - B-1 // B * A
print(ans) | A, B, N = map(int, input().split())
if N < B:
ans = A * N // B - N // B * A
else:
ans = A * (B-1) // B - (B-1) // B * A
print(ans) | [] | 444,538 | 444,539 | u607075479 | python |
p02696 | A,B,N = map(int,input().split())
ans = ((A*N)//B) - A * (N//B)
if B-1 >= N:
tmp = ((A*(B-1))//B) - A * ((B-1)//B)
ans = max(ans,tmp)
print(ans) | A,B,N = map(int,input().split())
ans = ((A*N)//B) - A * (N//B)
if B-1 <= N:
tmp = ((A*(B-1))//B) - A * ((B-1)//B)
ans = max(ans,tmp)
print(ans) | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,599 | 444,600 | u391731808 | python |
p02696 | a,b,n=map(int,input().split())
x=min(b-1,x)
print(a*x//b) | a,b,n=map(int,input().split())
x=min(b-1,n)
print(a*x//b) | [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 444,627 | 444,628 | u568576853 | python |
p02696 | a, b, n = map(int, input().split())
if n > b:
print(((a*(-1))//b) - (a*((-1)//b)))
else:
print(((a*n)//b) - (a*(n//b)))
| a, b, n = map(int, input().split())
if n >= b:
print(((a*(-1))//b) - (a*((-1)//b)))
else:
print(((a*n)//b) - (a*(n//b)))
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,647 | 444,648 | u730257868 | python |
p02696 | # -*- coding: utf-8 -*-
A,B,N = map(int, input().split())
if N > B:
x = B - 1
z = (A * x) // B - A * (x // B)
else:
x = N
z = (A * x) // B - A * (x // B)
print(int(z)) | # -*- coding: utf-8 -*-
A,B,N = map(int, input().split())
if N >= B:
x = B - 1
z = (A * x) // B - A * (x // B)
else:
x = N
z = (A * x) // B - A * (x // B)
print(int(z)) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,655 | 444,656 | u084491185 | python |
p02696 | # -*- coding: utf-8 -*-
A,B,N = map(int, input().split())
if N >= B:
x = B
z = (A * x) // B - A * (x // B)
else:
x = N
z = (A * x) // B - A * (x // B)
print(int(z)) | # -*- coding: utf-8 -*-
A,B,N = map(int, input().split())
if N >= B:
x = B - 1
z = (A * x) // B - A * (x // B)
else:
x = N
z = (A * x) // B - A * (x // B)
print(int(z)) | [
"assignment.change"
] | 444,657 | 444,656 | u084491185 | python |
p02696 | A,B,N = map(int,input().split())
def func(x):
return int((A*x)/B) - A * int(x/B)
if N < B:
print(func(N))
else:
print(B-1) | A,B,N = map(int,input().split())
def func(x):
return int((A*x)/B) - A * int(x/B)
if N < B:
print(func(N))
else:
print(func(B-1)) | [
"call.arguments.add",
"call.arguments.change"
] | 444,681 | 444,682 | u783674761 | python |
p02696 | a,b,n=map(int,input().split())
nmax = (a*n)//b - a*(n//b)
x = b-1
xmax = (a*x)//b - a*(x//b)
print(max(nmax,xmax)) | a,b,n=map(int,input().split())
nmax = (a*n)//b - a*(n//b)
x = b-1
xmax = (a*x)//b - a*(x//b)
print(max(nmax,xmax) if x < n else nmax) | [] | 444,686 | 444,687 | u996665352 | python |
p02696 | a,b,n = map(int,input().split())
i = max(b-1,n)
ans = a*i//b - a*(i//b)
print(ans) | a,b,n = map(int,input().split())
i = min(b-1,n)
ans = a*i//b - a*(i//b)
print(ans) | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 444,690 | 444,691 | u969211566 | python |
p02696 | import math
a,b,n=map(int,input().split())
max=-2
if n<b:
max=math.floor(a*n/b)
else:
#b<=n
max=math.floor(a*b-1/b)
#s2=math.floor(a*((1/b)-i//b))
print(max)
| import math
a,b,n=map(int,input().split())
max=-2
if n<b:
max=math.floor(a*n/b)
else:
#b<=n
max=math.floor(a*(b-1)/b)
print(max)
| [
"call.arguments.change"
] | 444,710 | 444,711 | u196746947 | python |
p02696 | import math
A,B,N=map(int,input().split())
x=min(B-1,N)
ans=math.ceil(A*x/B)-A*math.ceil(x/B)
print(int(ans))
| import math
A,B,N=map(int,input().split())
x=min(B-1,N)
ans=math.floor(A*x/B)-A*math.floor(x/B)
print(int(ans))
| [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 444,717 | 444,718 | u692311686 | python |
p02696 | a,b,n=list(map(int,input().split()))
ans=0
#for x in range(n+1):
if a==b==n:
x=n-1
else:
x=b-1 if n-1>=b else n
ans=int(a*x/b)-a*int(x/b)
print(ans)
#print(x,int(a*x/b),int(x/b)*a,ans) | a,b,n=list(map(int,input().split()))
ans=0
#for x in range(n+1):
if b==n:
x=n-1
else:
x=b-1 if n-1>=b else n
ans=int(a*x/b)-a*int(x/b)
print(ans)
#print(x,int(a*x/b),int(x/b)*a,ans) | [] | 444,723 | 444,724 | u464205401 | python |
p02696 | def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
a,b,n=n1()
import math
if b<=n:
i=b-1
else:
i=n
m=math.floor((a*i)/b)-a*math.floor(i//b)
print(i,m) | def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
a,b,n=n1()
import math
if b<=n:
i=b-1
else:
i=n
m=math.floor((a*i)/b)-a*math.floor(i/b)
print(m)
| [
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 444,725 | 444,726 | u920103253 | python |
p02696 | def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
a,b,n=n1()
import math
if b<=n:
i=b-1
else:
i=n
m=math.floor((a*i)/b)-a*math.floor(i//b)
print(i,m) | def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
a,b,n=n1()
import math
if b<=n:
i=b-1
else:
i=n
m=math.floor((a*i)/b)-a*math.floor(i//b)
print(m)
| [
"call.arguments.change"
] | 444,725 | 444,727 | u920103253 | python |
p02696 | def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
a,b,n=n1()
if b<=n:
i=b
else:
i=n
m=(a*i)//b-a*(i//b)
print(m) | def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
a,b,n=n1()
if b<=n:
i=b-1
else:
i=n
m=(a*i)//b-a*(i//b)
print(m) | [
"assignment.change"
] | 444,728 | 444,729 | u920103253 | python |
p02696 | import math
a,b,n = map(int,input().split())
c = 0
ans = -1
for i in range(1,n//b+1) :
x = b*i-1
if x > n :
x = n
c = 1
if ans >= math.floor((a*x)/b)-a*math.floor(x/b) :
break
ans = math.floor((a*x)/b)-a*math.floor(x/b)
if c == 1 :
break
print(ans) | import math
a,b,n = map(int,input().split())
c = 0
ans = -1
for i in range(1,n//b+2) :
x = b*i-1
if x > n :
x = n
c = 1
if ans >= math.floor((a*x)/b)-a*math.floor(x/b) :
break
ans = math.floor((a*x)/b)-a*math.floor(x/b)
if c == 1 :
break
print(ans) | [
"literal.number.integer.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.range.bounds.upper.change"
] | 444,735 | 444,736 | u454557108 | python |
p02696 | import math
a,b,n = map(int,input().split())
c = 0
ans = -1
for i in range(1,n//b+1) :
x = b*i-1
if x > n :
x = n
c = 1
if ans > math.floor((a*x)/b)-a*math.floor(x/b) :
break
ans = math.floor((a*x)/b)-a*math.floor(x/b)
if c == 1 :
break
print(ans) | import math
a,b,n = map(int,input().split())
c = 0
ans = -1
for i in range(1,n//b+2) :
x = b*i-1
if x > n :
x = n
c = 1
if ans >= math.floor((a*x)/b)-a*math.floor(x/b) :
break
ans = math.floor((a*x)/b)-a*math.floor(x/b)
if c == 1 :
break
print(ans) | [
"literal.number.integer.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.range.bounds.upper.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,737 | 444,736 | u454557108 | python |
p02696 |
def solve():
if n > b:
print((b-1)*a//b)
else:
print((a*n)//b- a*(n//b))
return
# n = int(input())
a, b, n = [int(s) for s in input().split(" ")]
solve()
|
def solve():
if n >= b:
print((b-1)*a//b)
else:
print((a*n)//b- a*(n//b))
return
# n = int(input())
a, b, n = [int(s) for s in input().split(" ")]
solve()
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,743 | 444,744 | u618101737 | python |
p02696 | A,B,N=map(int,input().split())
def f(x):
return int(A*x/B)-A*int(x/B)
print(f(max(N,B-1))) | A,B,N=map(int,input().split())
def f(x):
return int(A*x/B)-A*int(x/B)
print(f(min(N,B-1))) | [
"misc.opposites",
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 444,747 | 444,748 | u870736713 | python |
p02696 | a, b, n = map(int, input().split())
x = min(b, n)
print(int(a * x / b))
| a, b, n = map(int, input().split())
x = min(b - 1, n)
print(int(a * x / b))
| [
"assignment.change"
] | 444,749 | 444,750 | u671446913 | python |
p02696 | a, b, n = map(int, input().split())
x = min(b. n)
print(int(a * x / b))
| a, b, n = map(int, input().split())
x = min(b - 1, n)
print(int(a * x / b))
| [
"assignment.value.change",
"call.arguments.change",
"call.arguments.add"
] | 444,751 | 444,750 | u671446913 | python |
p02696 | A,B,N = map(int,input().split())
if B < N:
print(((A*B)-A)//B)
else:
print((A*N)//B - A*(N//B)) | A,B,N = map(int,input().split())
if B <= N:
print(((A*B)-A)//B)
else:
print((A*N)//B - A*(N//B)) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 444,754 | 444,755 | u364862909 | python |
p02696 | A,B,N = map(int,input().split())
if B-1 >= N:
print(((A*B)-A)//B)
else:
print((A*N)//B - A*(N//B)) | A,B,N = map(int,input().split())
if B <= N:
print(((A*B)-A)//B)
else:
print((A*N)//B - A*(N//B)) | [
"control_flow.branch.if.condition.change"
] | 444,756 | 444,755 | u364862909 | python |
p02696 | A,B,N = map(int,input().split())
if B-1 >= N:
print(((A*B)-A)//B - A)
else:
print((A*N)//B - A*(N//B))
| A,B,N = map(int,input().split())
if B <= N:
print(((A*B)-A)//B)
else:
print((A*N)//B - A*(N//B)) | [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 444,757 | 444,755 | u364862909 | python |
p02696 | A,B,N = map(int,input().split())
if B-1 <= N:
print(((A*B)-A)//B - A)
else:
print((A*N)//B - A*(N//B)) | A,B,N = map(int,input().split())
if B <= N:
print(((A*B)-A)//B)
else:
print((A*N)//B - A*(N//B)) | [
"expression.operation.binary.remove"
] | 444,758 | 444,755 | u364862909 | python |
p02696 | import math
a,b,n=map(int, input().split())
max = 0
tmp = 0
if n >= b:
max = math.floor(a * (b + 1) / b) - a * math.floor((b + 1) / b)
else:
max = math.floor(a * n / b) - a * math.floor(n / b)
print(max) | import math
a,b,n=map(int, input().split())
max = 0
tmp = 0
if n >= b:
max = math.floor(a * (b - 1) / b) - a * math.floor((b - 1) / b)
else:
max = math.floor(a * n / b) - a * math.floor(n / b)
print(max) | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 444,759 | 444,760 | u630554891 | python |
p02696 | import math
a, b, n = map(int,input().split())
x = min(b, n)
print(int(math.floor(a*x/b) - a * math.floor(x/b))) | import math
a, b, n = map(int,input().split())
x = min(b-1, n)
print(int(math.floor(a*x/b) - a * math.floor(x/b))) | [
"assignment.change"
] | 444,761 | 444,762 | u175034939 | python |
p02696 | import math
a, b, n = map(int,input().split())
x = min(b, n)
print(math.floor(a*x/b) - a * math.floor(x/b)) | import math
a, b, n = map(int,input().split())
x = min(b-1, n)
print(int(math.floor(a*x/b) - a * math.floor(x/b))) | [
"call.arguments.add",
"call.arguments.change"
] | 444,763 | 444,762 | u175034939 | python |
p02696 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
a, b, n = map(int, input().split())
if n >= b:
x = b-1
else:
x = b
print(a*x//b-a*(x//b)) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
a, b, n = map(int, input().split())
if n >= b:
x = b-1
else:
x = n
print(a*x//b-a*(x//b)) | [
"assignment.value.change",
"identifier.change"
] | 444,773 | 444,774 | u737298927 | python |
p02696 | import sys
from math import sqrt, floor
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
def I():
return int(input())
def MI():
return map(int, input().split())
def main():
a, b, n = MI()
if b < n:
print((a * (b - 1)) // b)
else:
print((a * n) // b)
if __name__ == ... | import sys
from math import sqrt, floor
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
def I():
return int(input())
def MI():
return map(int, input().split())
def main():
a, b, n = MI()
if b - 1 <= n:
print((a * (b - 1)) // b)
else:
print((a * n) // b)
if __name_... | [
"control_flow.branch.if.condition.change"
] | 444,777 | 444,776 | u876438858 | python |
p02696 | import sys
from math import sqrt, floor
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
def I():
return int(input())
def MI():
return map(int, input().split())
def main():
a, b, n = MI()
if b < n:
print((a * (b - 1)) // b)
else:
print((a * n) // b - (a * (n // b)))
... | import sys
from math import sqrt, floor
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
def I():
return int(input())
def MI():
return map(int, input().split())
def main():
a, b, n = MI()
if b - 1 <= n:
print((a * (b - 1)) // b)
else:
print((a * n) // b - (a * (n // ... | [
"control_flow.branch.if.condition.change"
] | 444,778 | 444,779 | u876438858 | python |
p02696 | import math
A, B, N = map(int, input().split())
x = max(B-1, N)
print(math.floor((A*x)/B)-A*(x//B))
| import math
A, B, N = map(int, input().split())
x = min(B-1, N)
print(math.floor((A*x)/B)-A*(x//B))
| [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 444,780 | 444,781 | u189487046 | python |
p02696 | def d():
import math
a, b, n = map(int, input().split())
# x <= n
x = min(b, n) - 1
print(math.floor(a*x/b) - a * math.floor(x/b))
##########
if __name__ == "__main__":
d()
| def d():
import math
a, b, n = map(int, input().split())
# x <= n
x = min(b-1, n)
print(math.floor(a*x/b) - a * math.floor(x/b))
##########
if __name__ == "__main__":
d()
| [
"expression.operation.binary.remove"
] | 444,785 | 444,786 | u517910772 | python |
p02696 | def d():
import math
a, b, n = map(int, input().split())
# x <= n
x = min(b, n)
print(math.floor(a*x/b) - a * math.floor(x/b))
##########
if __name__ == "__main__":
d()
| def d():
import math
a, b, n = map(int, input().split())
# x <= n
x = min(b-1, n)
print(math.floor(a*x/b) - a * math.floor(x/b))
##########
if __name__ == "__main__":
d()
| [
"assignment.change"
] | 444,787 | 444,786 | u517910772 | python |
p02696 | a, b, n = map(int, input().split())
x = min(b-1, n)
ans = max(int((a*x)/b) - a*int(x/b))
print(ans)
| a, b, n = map(int, input().split())
x = min(b-1, n)
ans = int((a*x)/b) - a*int(x/b)
print(ans)
| [
"call.remove",
"call.arguments.change"
] | 444,801 | 444,802 | u781535828 | python |
p02696 | import math
a,b,n=map(int, input().split())
if n>b:
print(math.floor(a*(b-1)/b))
else:
print(math.floor(a*n/b)) | import math
a,b,n=map(int, input().split())
if n>b-1:
print(math.floor(a*(b-1)/b))
else:
print(math.floor(a*n/b)) | [
"control_flow.branch.if.condition.change"
] | 444,805 | 444,806 | u755801379 | python |
p02696 | A, B, N = map(int,input().split())
def fl(i):
return ((A * i) // B) - (A * (i // B))
if B <= N:
print(int(fl(B / A * (A - 1))))
else:
print(int(fl(N))) | A, B, N = map(int,input().split())
def fl(i):
return ((A * i) // B) - (A * (i // B))
if B <= N:
print(int(fl(B - 1)))
else:
print(int(fl(N))) | [
"expression.operation.binary.remove",
"call.arguments.change"
] | 444,807 | 444,808 | u874333466 | python |
p02696 | A,B,N = map(int,input().split())
if B >= N - 1:
print(A * N // B)
else:
print(A * (B-1) // B) | A,B,N = map(int,input().split())
if B >= N + 1:
print(A * N // B)
else:
print(A * (B-1) // B) | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 444,813 | 444,814 | u278260569 | python |
p02698 | from bisect import bisect
from sys import setrecursionlimit
setrecursionlimit(10000000)
N = int(input())
A = tuple(map(int,input().split()))
adj = [list() for _ in range(N)]
for _ in range(N-1):
a,b = map(int,input().split())
a,b = a-1,b-1
adj[a].append(b)
adj[b].append(a)
res = [None]*N
dp = [float... | from bisect import bisect
from sys import setrecursionlimit
setrecursionlimit(10000000)
N = int(input())
A = tuple(map(int,input().split()))
adj = [list() for _ in range(N)]
for _ in range(N-1):
a,b = map(int,input().split())
a,b = a-1,b-1
adj[a].append(b)
adj[b].append(a)
res = [None]*N
dp = [float... | [
"assignment.change"
] | 445,616 | 445,617 | u327466606 | python |
p02698 | import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
from collections import deque, defaultdict
from itertools import combinations, permutations
from itertools import accumulate
from math import ceil, sqrt, pi
def... | import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
from collections import deque, defaultdict
from itertools import combinations, permutations
from itertools import accumulate
from math import ceil, sqrt, pi
def... | [
"control_flow.branch.if.add"
] | 445,622 | 445,623 | u296518383 | python |
p02698 | #from collections import deque,defaultdict
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**12
R = 10**9 + 7
#R = 998244353
def ddprint(x):
if D... | #from collections import deque,defaultdict
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**12
R = 10**9 + 7
#R = 998244353
def ddprint(x):
if D... | [] | 445,754 | 445,755 | u102445737 | python |
p02698 | import sys
import math
import heapq
import bisect
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return map(int, sys.st... | import sys
import math
import heapq
import bisect
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return map(int, sys.st... | [] | 445,767 | 445,768 | u895515293 | python |
p02698 | import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(... | import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(... | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 445,813 | 445,814 | u531436689 | python |
p02698 | from bisect import bisect_left, bisect_right
import sys
def main():
input = sys.stdin.readline
N=int(input())
*A,=map(int, input().split())
G=[[] for _ in range(N)]
for _ in range(N-1):
u,v=map(int, input().split())
u,v=u-1,v-1
G[u].append(v)
G[v].append(u)
INF=1... | from bisect import bisect_left
import sys
def main():
input = sys.stdin.readline
N=int(input())
*A,=map(int, input().split())
G=[[] for _ in range(N)]
for _ in range(N-1):
u,v=map(int, input().split())
u,v=u-1,v-1
G[u].append(v)
G[v].append(u)
INF=10**10
ans=... | [
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 445,815 | 445,816 | u852690916 | python |
p02696 | import math
def func(A, B, x):
return math.floor(A*x/B)-A*math.floor(x/B)
A, B, N = list(map(int, input().split()))
"""
i = 1
max_x = -9999999
max = -9999999
while (i <= N):
ans =func(A, B, i)
if (ans > max):
max = ans
max_x = i
i += 1
print(max)
"""
print(func(A, B, B-1)) | import math
def func(A, B, x):
return math.floor(A*x/B)-A*math.floor(x/B)
A, B, N = list(map(int, input().split()))
"""
i = 1
max_x = -9999999
max = -9999999
while (i <= N):
ans =func(A, B, i)
if (ans > max):
max = ans
max_x = i
i += 1
print(max)
"""
print(func(A, B, min(B-1, N))) | [
"call.add",
"call.arguments.add",
"call.arguments.change"
] | 445,827 | 445,828 | u880400515 | python |
p02696 | #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
a,b,n = map(int,input().split())
if b-1 >= n:
x = b-1
else:
x = n
print((a*x//b)-(a*(x//b))) | #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
a,b,n = map(int,input().split())
if b-1 <= n:
x = b-1
else:
x = n
print((a*x//b)-(a*(x//b))) | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 445,868 | 445,869 | u716530146 | python |
p02699 | a,b=map(int,input().split())
if b>a:
print("unsafe")
else:
print("safe") | a,b=map(int,input().split())
if b>=a:
print("unsafe")
else:
print("safe") | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 445,889 | 445,890 | u422977492 | python |
p02699 | a, b = map(int, input().split())
print('unsafe' if a < b else 'safe') | a, b = map(int, input().split())
print('unsafe' if a <= b else 'safe') | [
"expression.operator.compare.change",
"call.arguments.change",
"io.output.change"
] | 445,897 | 445,898 | u328510800 | python |
p02699 |
a = list.map(int,input().split())
if a[1] >= a[0]:
print("unsafe")
else:
print("safe") | a = list(map(int,input().split()))
if a[1] >= a[0]:
print("unsafe")
else:
print("safe") | [
"assignment.value.change",
"call.arguments.change"
] | 445,906 | 445,907 | u763628696 | python |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.