qyliang/CodeNanoFix huggingface dataset:
Buggy code:
a,d,x = map(int,input().split())

for i in range(10):
  s = r*x-d
  print(s)
  x = s
  

Fixed code:
r,d,x = map(int,input().split())

for i in range(10):
  s = r*x-d
  print(s)
  x = s
Buggy code:
r,d,x=map(int,input().split())
def algae(n):
    if n==1:
        return x
    else:
        return r*algae(n-1)-d
for i in range(2,12):
    algae(i)

Fixed code:
r,d,x=map(int,input().split())
def algae(n):
    if n==1:
        return x
    else:
        return r*algae(n-1)-d
for i in range(2,12):
    print(algae(i))
Buggy code:
r, d, x_2000 = map(int, input().split())
ans = []*11
ans[0] = x_2000
for i in range(1, 11):
    ans[i] = r * ans[i-1] - d
    print(ans[i])

Fixed code:
r, d, x_2000 = map(int, input().split())
ans = [0]*11
ans[0] = x_2000
for i in range(1, 11):
    ans[i] = r * ans[i-1] - d
    print(ans[i])
Buggy code:
r,d,x0 = map(int,input().split())

xlist = []

xlist.append(r*x0-d)

for i in range(9):
    xlist.append(r*xlist[i]-d)
    print(xlist[i])




Fixed code:
r,d,x0 = map(int,input().split())

xlist = []

xlist.append(r*x0-d)

for i in range(10):
    xlist.append(r*xlist[i]-d)
    map(int,xlist)
    print(xlist[i])
Buggy code:
str = input().split()

r = int(str[0])
D = int(str[1])
x2000 = int(str[2])

for i in range(10):
  print(x2000 = (r*x2000-D))
  

Fixed code:
str = input().split()

r = int(str[0])
D = int(str[1])
x2000 = int(str[2])

for i in range(10):
  print(r*x2000-D)
  x2000 = r*x2000-D
Buggy code:
r,D,x = map(int,input().split())
for i in range(9):
  x = r * x -D
  print(x)

Fixed code:

r, D, x = map(int, input().split())

for i in range(10):
    x = r*x - D
    print(x)
Buggy code:
r,t,x=map(int,input().split())
print(a=r*x-t)
print(b=r*a-t)
print(c=r*b-t)
print(d=r*c-t)
print(e=r*d-t)
print(f=r*e-t)
print(g=r*f-t)
print(h=r*g-t)
print(i=r*h-t)
print(j=r*i-t)


Fixed code:
r,t,x=map(int,input().split())
a=r*x-t
b=r*a-t
c=r*b-t
d=r*c-t
e=r*d-t
f=r*e-t
g=r*f-t
h=r*g-t
i=r*h-t
j=r*i-t
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
print(g)
print(h)
print(i)
print(j)
Buggy code:
r, d, x = map(int, input().split())
for i in range(10):
	x = r * x - d
    print(x)

Fixed code:
r,d,x=map(int,input().split())

for _ in range(10):
    x=x*r-d
    print(x)
Buggy code:
r,D,x = map(int,input().split())
ans = x
for i in range(1,D+1):
  ans = ans*r - D
  print(ans)

Fixed code:
r,D,x = map(int,input().split())
ans = x
for i in range(1,11):
  ans = ans*r - D
  print(ans)
Buggy code:
r, d, x_2000 = map(int, input().split(' '))
a = [x_2000] + [0] * 10
for i in range(1, 11):
  a[i] = r * a[i - 1] - d

[print(x) for x in a]

Fixed code:
r, d, x_2000 = map(int, input().split(' '))
a = [x_2000] + [0] * 10
for i in range(1, 11):
  a[i] = r * a[i - 1] - d
  print(a[i])
Buggy code:
r, d, x = map(int,input().split())

result = r*x-d
for i in range(9):
  result = r*result-d
  print(result)


Fixed code:
r,d,x=map(int,input().split())
ans=r*x-d
print(ans)
for i in range(9):
  ans = (ans*r)-d
  print(ans)
Buggy code:
r,d,x = map(int,input(),.split())

for i in range(10):
  x = r*x-d
  print(x)


Fixed code:
r, d, x = map(int, input().split())

for i in range(10):
  x = x * r - d
  print(x)
Buggy code:

r,d,x_2000=map(int,input().split())

def X(n):    
    if n == 1:return x_2000
    else:return r*X(n-1)-d
print([X(n) for n in range(2,12)])

Fixed code:

r,d,x_2000=map(int,input().split())

def X(n):    
    if n == 1:return x_2000
    else:return r*X(n-1)-d
lis=[X(n) for n in range(2,12)]
[print(i) for i in lis]
Buggy code:
r,d,x=map(int,input().split())
for i in range(10)
  x=r*x-d
  print(x)


Fixed code:
r, d, x = list(map(int, input().split()))

for i in range(10):
    x = r * x - d
    print(x)
Buggy code:
r,D,x=list((map(int,input().split())))
for _ in range(20):
    x=x*r-D
    print(x)

Fixed code:
r,D,x=list((map(int,input().split())))
for _ in range(10):
    x=x*r-D
    print(x)
Buggy code:
r,D,x=map(int,input().split())
for i in range(10):
    x=r*x-D
print(x)

Fixed code:
r, D, x2000 = map(int, input().split())

x = x2000
for i in range(10):
    x = x * r - D
    print(x)
Buggy code:
r,d,x = map(int,input().split())
p = []
for i in range(10):
    x = r * x - d
    p[i] = x

for i in range(10):
    print(p[i])

Fixed code:
r,d,x = map(int,input().split())
p = []
for i in range(10):
    x = r * x - d
    p.append(x)

for i in range(10):
    print(p[i])
Buggy code:
r,d,x=map(int,input().split())
for _ in range(10):
	x=x*2-10
	print(x)

Fixed code:
r,d,x=map(int,input().split())
for _ in range(10):
	x=x*r-d
	print(x)
Buggy code:
read=input
r,d,x=map(int,read()).split(' ')
for i in range(10):
  x=int(r*x-d)
  print(x)

Fixed code:
read=input
r,d,x=map(int,read().split(' '))
for i in range(10):
  x=int(r*x-d)
  print(x)
Buggy code:
r,d,x = map(int,input().split())

def ike(n,r,d,x):
    if n == 0:
        return x
    return r*ike(n-1,r,d,x)-d

if __name__ == "__main__":
    for i in range(10):
        print(ike(i,r,d,x)) 

Fixed code:
r,d,x = map(int,input().split())

def ike(n,r,d,x):
    if n == 0:
        return x
    return r*ike(n-1,r,d,x)-d

if __name__ == "__main__":
    for i in range(10):
        print(ike(i+1,r,d,x))
Buggy code:
import sys
input = sys.stdin.readline

def main():
    r, D, x = [int(x) for x in input().split()]
    next_year = x
    for _ in range(10):
        next_year = r * next_year - D


if __name__ == '__main__':
    main()



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

def main():
    r, D, x = [int(x) for x in input().split()]
    next_year = x
    for _ in range(10):
        next_year = r * next_year - D
        print(next_year)


if __name__ == '__main__':
    main()
Buggy code:
r,D,x=map(int, input().split())

a = [0]*11
a[0] = x

for i in range(1,11):
  a[i] = r*a[i-1]-D

for i in a[0:11]:
    print(i)

Fixed code:
r,D,x=map(int, input().split())

a = [0]*11
a[0] = x

for i in range(1,11):
  a[i] = r*a[i-1]-D

for i in a[1:11]:
    print(i)
Buggy code:
a,b,c=(int(i) for i in input().split())
for i in range(1,10):
  c=a*c-b
  print(c)


Fixed code:
a,b,c=(int(i) for i in input().split())
for i in range(10):
  c=a*c-b
  print(c)
Buggy code:
x=input()
xx=x.split()
r=int(xx[0])
x=int(xx[1])
D=int(xx[2])
y=[0]*10
for i in range(10):
  y[i]+=r*x-D
  print(y[i])
  x=y[i]

Fixed code:
x=input()
xx=x.split()
r=int(xx[0])
D=int(xx[1])
x2=int(xx[2])
y=[0]*10
for i in range(10):
  y[i]+=r*x2-D
  print(y[i])
  x2=y[i]
Buggy code:
r, D, x0 = list(map(int, input().split()))
for i in range():
  x1 = r * x - D
  x = x1
  print(x1)

Fixed code:
r, D, x0 = list(map(int, input().split()))
for i in range(10):
  x1 = r * x0 - D
  x0 = x1
  print(x1)
Buggy code:
r d x = map(int, input().split())

for i range (10):
    ans = x * r - d
    print(ans)
    x = ans

Fixed code:
r,d,x = map(int, input().split())

for i in range(10):
    ans = x * r - d
    print(ans)
    x = ans
Buggy code:
r, d, start = map(int,input().split())
X = [start]
for i in range(10):
    X.append(r*X[-1]-d)
print(*X,sep="\n")

Fixed code:
r, d, start = map(int,input().split())
X = [start]
for i in range(10):
    X.append(r*X[-1]-d)
print(*X[1:],sep="\n")
Buggy code:
r, d, x = map(int,input().split())
print((x = x * r - k ) for _ in range(10))

Fixed code:
r, d, x = map(int,input().split())
for _ in range(10):
    x = x * r - d
    print(x)
Buggy code:
r, d, x = map(int, input().split())

for i in range(10):
    x = r*x-d
    print(xi)


Fixed code:
r,d,x = map(int,input().split())
for i in range(10):
    x = r * x - d
    print(x)
Buggy code:
from sys import stdin
import numpt as np

def main(args):
    r = args[0]
    d = args[1]
    x = args[2]
    ar = np.zeros([10])

    ar[0] = r*x-d
    for i in range(1,len(ar)):
        ar[i] = r*ar[i-1]-d

    for i in ar:
        print(i)

if __name__ == "__main__":
    main([int(x) for x in stdin.readline().rstrip().split()])

Fixed code:
from sys import stdin
import numpy as np

def main(args):
    r = int(args[0])
    d = int(args[1])
    x = int(args[2])
    ar = np.zeros([10], dtype=int)

    ar[0] = r*x-d
    for i in range(1,len(ar)):
        ar[i] = r*ar[i-1]-d

    for i in ar:
        print(i)

if __name__ == "__main__":
    main(stdin.readline().rstrip().split())
Buggy code:
r, D, x = map(int, input().split)


for i in range(10):
  x = (r * x) - D
  print(x)

Fixed code:
r, D, x = map(int, input().split())


for i in range(10):
  x = (r * x) - D
  print(x)
Buggy code:
r, D, x_2000 = map(int, input()split())


for i in range(1,11):
  x = r*x_2000 - D
  print(x)
  x_2000 = x
  

Fixed code:
r, D, x = map(int, input().split())
for i in range(1, 11):
  x = r * x - D
  print(x)
Buggy code:
r,d,x_2000=map(int,input().split())
x_i = x_2000
for i in range(10):
  x_ii = r*x_i-D
  x_i = x_ii
  print(x_ii)

Fixed code:
r,d,x_2000=map(int,input().split())
x_i = x_2000
for i in range(10):
  x_ii = r*x_i-d
  x_i = x_ii
  print(x_ii)
Buggy code:
r, d, x = map(int, input().split())
for _ in range(10):
	x = x * r - d
    print(x)


Fixed code:
r, d, x = map(int, input().split())
for _ in range(10):
    x = x * r - d
    print(x)
Buggy code:
r,d,x = map(int,input().split())
 
for i in range(10):
  x = r*x - d
  print(r)

Fixed code:
r, d, x2000 = map(int, input().split())

x = x2000
for i in range(10):
    x = r * x - d
    print(x)
Buggy code:
r,d,x0=map(int,input().split())
for i in range(10):
  x0=xo*r-d
  print (x0)

Fixed code:
r,d,x0=map(int,input().split())
for i in range(10):
  x0=x0*r-d
  print (x0)
Buggy code:
r, d, x = map(int, input().split())

for i in range(10):
    x = (r * x) - D
    print(x)


Fixed code:
r, D, x = map(int, input().split())
X = x
for i in range(10):
    print(r*X - D)
    X = r*X - D
Buggy code:
r,d,x=input().split()
m = int(x)
for i in range(1, 10):
    m = int(r) * int(m) - int(d)
    print(int(m))

Fixed code:
r,d,x=input().split()
m = int(x)
for i in range(1, 11):
    m = int(r) * int(m) - int(d)
    print(int(m))
Buggy code:
r,d,x = map(int,input().split())
for _ in range(10):
  print(x)
  x = x*r-d

Fixed code:
r, d, x= map(int, input().split())
x_now = x
for _ in range(10):
    x_next = r*x_now - d
    x_now = x_next
    print(x_next)
Buggy code:
r,d,x = map(int,input().split())
ansl =[x]
for i in range(10):
  ans = r*ansl[i] - d
  print(ans)

Fixed code:
r,d,x = map(int,input().split())
ansl =[x]
for i in range(10):
  ans = r*ansl[i] - d
  print(ans)
  ansl.append(ans)
Buggy code:
r,d,x = map(int, input().split())

L = [x]
for i in range(1,11):
  L.append(L[i-1]*r - d)
  
for i in range(len(L)):
  print(L[i])

Fixed code:
r,d,x = map(int, input().split())

L = [x]
for i in range(1,11):
  L.append(L[i-1]*r - d)
  
L.pop(0)
for i in range(len(L)):
  print(L[i])
Buggy code:
r, D, x = map(int, input().split())
for i in range(10):
  r = r * x - D
  print(r)

Fixed code:
r, D, x = map(int,input().split())
for i in range(10):
    x = r*x-D 
    print(x)
Buggy code:
r, d, x = map(int, input().split())
xs = [x]
for i in range(10):
    xs.append(xs[-1] * r - d)
print("\n".join(map(str, xs)))

Fixed code:
r, d, x = map(int, input().split())
xs = [x]
for i in range(10):
    xs.append(xs[-1] * r - d)
print("\n".join(map(str, xs[1:])))
Buggy code:
r, D, x = map(int, input().split())
ansLst = [0] * 10
print(ansLst)
ansLst[0] = int((r * x) - D)
for i in range(1, 10):
    ansLst[i] = int((ansLst[i - 1] * r) - D)
for i in ansLst:
    print(i)

Fixed code:
r, D, x = map(int, input().split())
ansLst = [0] * 10

ansLst[0] = int((r * x) - D)
for i in range(1, 10):
    ansLst[i] = int((ansLst[i - 1] * r) - D)
for i in ansLst:
    print(i)
Buggy code:
r,D,x = [int(i) for i in input().split()]
n=2000
while n <=2010: 
  print(x) 
  X=r*x-D
  x=X
  n=n+1
        

Fixed code:
r,D,x = [int(i) for i in input().split()]
n=2000
X=r*x-D
x=X
while n <=2009: 
  print(x) 
  X=r*x-D
  x=X
  n=n+1
Buggy code:
r,D,x=[int(i) for i in input().split()]
a = x
for i in range(D):
    a = (r*a) - D
    print(a)

Fixed code:
r,D,x=[int(i) for i in input().split()]
for i in range(10):
    x = int((r*x) - D)
    print(x)
Buggy code:
r,D,x2000=[int(x) for x in input().split()]
x=[x2000]
for i in range(10):
    x.append(x[i]*r-D)
for xi in x:
    print(xi)

Fixed code:
r,D,x2000=[int(x) for x in input().split()]
x=[x2000]
for i in range(10):
    x.append(x[i]*r-D)
for xi in x[1:]:
    print(xi)
Buggy code:
r, D, x = list(map(lambda a: int(a), input().split(" ")))

ans = []
for i in range(10):
  x = r * x - D
  ans.append(x)

print("\n".join(str(ans)))

Fixed code:
r, D, x = list(map(lambda a: int(a), input().split(" ")))
 
ans = []
for i in range(10):
  x = r * x - D
  ans.append(str(x))
 
print("\n".join(ans))
Buggy code:
s=list(map(int,input()))
for i in range(10):
  s[2]=s[0]*s[2]-s[1]
  print(s[2])


Fixed code:
s=list(map(int,input().split()))
for i in range(10):
  s[2]=s[0]*s[2]-s[1]
  print(s[2])
Buggy code:
r,D,x=map(int,input().split())
for i in range(10):
	x=r*x-D
    print(x)

Fixed code:
r,D,x = map(int, input().split())
for i in range(10):
    print(r*x - D)
    x = r*x - D
Buggy code:
r, D, x0 = map.(int, input().split())
x_tmp = x0

for i in range(1, 11):
  x = r * x_tmp - D
  print(x)

Fixed code:
r, D, x0 = map(int, input().split())
x_tmp = x0
 
for i in range(1, 11):
  x = r * x_tmp - D
  x_tmp = x
  print(x)
Buggy code:
r,D,x=map(int,input().split())
for i in range(2001,2011,1):
    print(x)
    x_=r*x-D
    x=x_

Fixed code:
r,D,x=map(int,input().split())
for i in range(2001,2011,1):
    x_=r*x-D
    x=x_
    print(x)
Buggy code:
r, d, x = map(int, input().split())

for i in range(11):
  x = r * x - d
  print(x)

Fixed code:
r,d,x=map(int,input().split())
for i in range(10):
    x=r*x-d
    print(x)
Buggy code:
# ABC 127, B - algae
tmp = [int(el) for el in input().split(' ')]
r = tmp[0]
d = tmp[1]
X = [0 for i in range(11)]
X[0] = tmp[2]

print(r, d, X[0])

for i in range(1, 11):
    X[i] = r*X[i-1] - d
    print(X[i])


Fixed code:
# ABC 127, B - algae
tmp = [int(el) for el in input().split(' ')]
r = tmp[0]
d = tmp[1]
X = [0 for i in range(11)]
X[0] = tmp[2]


for i in range(1, 11):
    X[i] = r*X[i-1] - d
    print(X[i])
Buggy code:
r, d, x = map(int, input().strip())
for i in range(10):
  x = r * x - d
  print(x)


Fixed code:
r, d, x = map(int, input().split())
for i in range(10):
  x = r * x - d
  print(x)
Buggy code:
r, D, x = map(int,input().split())
dp = [0]*11
dp[0]=x
for i in range(10):
  dp[i+1] = r*dp[i] - D
  
print(dp[-1])

Fixed code:

r, D, x = map(int, input().split())
X = [x] + [0 for i in range(10)]
for i in range(1, 11):
        X[i] = X[i-1] * r - D
        print(X[i])
Buggy code:
r,d,x=map(int,input().split())
for i in range(11):
    print(str(x))
    x = x * r - d


Fixed code:
r,d,x=map(int,input().split())
for i in range(10):
    x = x * r - d
    print(str(x))
Buggy code:
r, d, x = map(int, input().split())
for _ in range(10):
  x = r * x -d
print(x)


Fixed code:
r, d, x = map(int, input().split())
for _ in range(10):
  x = r * x -d
  print(x)
Buggy code:
ints = input().split(' ')
r, D, x_0 = int(ints[0]), int(ints[1]), int(ints[2])

def calc(i):
	if i==2000:
		return r*x_0-D
	else:
		return r*calc(i-1)-D
for i in range(2001, 2010):
	print(calc(i))

Fixed code:
ints = input().split(' ')
r, D, x_0 = int(ints[0]), int(ints[1]), int(ints[2])

def calc(i):
	if i==2000:
		return x_0
	else:
		return r*calc(i-1)-D
for i in range(2001, 2011):
	print(calc(i))
Buggy code:
r,d,x = map(int,input().split())
for i in range(1,11):
  w = r*x - d
  x = w
  print(W)

Fixed code:
r,d,x = map(int,input().split())
for i in range(1,11):
  x = r*x - d
  print(x)
Buggy code:
r,d,x = map(int, input().split())

count = 0
while count < 11:
  x = r*x-d
  print(x)
  count += 1
  

Fixed code:
r,d,x = map(int, input().split())

count = 0
while count < 10:
  x = r*x-d
  print(x)
  count += 1
Buggy code:
r, d, x = map(int, input(),split())
for i in range(10):
  r = r*x-d
  print(r)

Fixed code:
r,d,x = map(int, input().split())
for i in range(10):
  x = r*x - d
  print(x)
Buggy code:
r, d, x = map(int, input().split())
for i in range(10):
  r = r*x-d
  print(r)

Fixed code:
r , D, x = map(int, input().split())
for i in range(10):
    print(r*x-D)
    x = r*x-D
Buggy code:
r D x = map(int, input.split())
for i in range(10):
  x = r * x - D
  print(x)

Fixed code:
r, D, x = map(int, input().split())
 
for i in range(10):
  x = r * x - D  
  print(x)
Buggy code:
a,b, c = map(int, input().split())
now = 0
for num in range(10):
    now = a*c -b
    print(now)

Fixed code:
a,b, c = map(int, input().split())
now = 0
for num in range(10):
    if num == 0:
        now = a * c -b
    else:
        now = a * now -b
    print(now)
Buggy code:
r,d,x=map(int,input().split())
for i in range(10):
  x=r*d-x
    print(x)

Fixed code:
r,d,x = map(int,input().split())

for _ in range(10):
    x = r * x - d
    print(x)
Buggy code:
r,d,x=map(int,input().split())
for i in range(10):
  x=r*x-D
  print(x)

Fixed code:
r,d, x = map(int, input().split())

for i in range(10):
    x  = r * x - d
    print(x)
Buggy code:
#ABC127 B

r,D,x = map(int,input().split())
A = []
for i in range(10):
    if i == 0:
        A.append(x)
    else:
        A.append(r*(A[i-1])-D)
print(A)

Fixed code:
#ABC127 B

r,D,x = map(int,input().split())
A = []
for i in range(11):
    if i == 0:
        A.append(x)
    else:
        A.append(r*(A[i-1])-D)

for j in range(10):
    print(A[j+1])
Buggy code:
arr = input.split()
r = int(arr[0])
d = int(arr[1])
x = int(arr[2])

for i in range(0,10):
  x = r*x - d
  print(x)

Fixed code:
arr = input().split()
r = int(arr[0])
d = int(arr[1])
x = int(arr[2])

for i in range(0,10):
  x = r*x - d
  print(x)
Buggy code:
r, d , x = map(int, input().split())
cnt = 0
print(x)
while cnt <= 10:
    x = r * x - d
    print(r * x - d)
    cnt += 1

Fixed code:
r, d , x = map(int, input().split())
cnt = 0
print(r * x - d)
while cnt <= 8:
    x = r * x - d
    print(r * x - d)
    cnt += 1
Buggy code:
r,x,d = map(int,input().split())
for i in range(10):
  x = r*x-d
  print(x)

Fixed code:
r, d, x= map(int, input().split())
for i in range(10):
    x = r*x-d
    print(x)
Buggy code:
r,D,x = map(int,input().split())
i = 0
while i <= 10:
    x = r * x - D
    print(x)
    i += 1
    


Fixed code:
r,D,x = map(int,input().split())
i = 0
while i < 10:
    x = r * x - D
    print(x)
    i += 1
Buggy code:
r, D, x = map(int, input().split())

for i in range(10):
    i = r * x - D

print(i)


Fixed code:

r,d,x=map(int,input().split())

for i in range(10):
    x=r*x-d
    print(x)
Buggy code:
r,d,x2000 = [int(i) for i in input().split()]

print(x2000)

xi = x2000

for i in range(10):
    xi = r*xi - d
    print(xi)

Fixed code:
r,d,x2000 = [int(i) for i in input().split()]

xi = x2000

for i in range(10):
    xi = r*xi - d
    print(xi)
Buggy code:
r,d,X=map(int,input().split())
x=[X]
for i in range(10):
    x.append(r*x[i]-d)
del x[0]
print(x)
for i in range(len(x)):
    print(x[i])

Fixed code:
r,d,X=map(int,input().split())
x=[X]
for i in range(10):
    x.append(r*x[i]-d)
del x[0]
#print(x)
for i in range(len(x)):
    print(x[i])
Buggy code:
r,d,x = map(int,input().split())
print(x)
for k in range(9):
  x = r*x -d
  print(x)

Fixed code:
r,d,x = map(int,input().split())
for k in range(10):
  x = r*x -d
  print(x)
Buggy code:
a,b,c = map(int,input().split())
def fib(n):
  if n == 0:
    return c
  else:
    return 2 * fib(n-1) -10
  
for i in range(10):
  print(fib(i+1))

Fixed code:
a,b,c = map(int,input().split())
def fib(n):
  if n == 0:
    return c
  else:
    return a * fib(n-1) -b
  
for i in range(10):
  print(fib(i+1))
Buggy code:
r,d,x = map(int,input().split())
for i in range(0,10):
  x = r+x-d
  print(x)

Fixed code:
r,d,x = map(int, input().split())

for i in range(0, 10):
    print(r * x - d)
    x = r * x - d
Buggy code:
r, D, x = map(int, input().split())
ans = r * x - D
final = []
for num in range(10):
    x = r * x - D
    final.append(x)
print(final)

Fixed code:
r, D, x = map(int, input().split())
final = []
for num in range(10):
    x = r * x - D
    final.append(x)
    print(final[num])
Buggy code:
s = input.split()
r = int(s[0])
D = int(s[1])
x = int(s[2])

for i in range(10):
    x = r * x - D
    print(x)

Fixed code:
s = input().split()
r = int(s[0])
D = int(s[1])
x = int(s[2])

for i in range(10):
    x = r * x - D
    print(int(x))
Buggy code:
r,D,x=map(int,input().split())

i=1
a=r*x-D
while i<=10:
	print(a)
    a=r*a-D
	i+=1

Fixed code:
r,D,x=map(int,input().split())

i=1
a=r*x-D

while i<=10:
	print(a)
	a=r*a-D
	i+=1
Buggy code:
r, d, x = map(int, input().split())
for i in range (1,11):
  x = (r*x)-d
print(x)

Fixed code:
r, d, x = map(int, input().split())
for i in range (1,11):
  x = (r*x)-d
  print(x)
Buggy code:
r, d, x2000 = map(int, input().split())

x = []

for i in range(10+1):
    x.append(0)

print(x)

x[0] = x2000
# print(x[0])

for i in range(10):
    x[i+1] = r * x[i] - d
    print(x[i+1])


Fixed code:
r, d, x2000 = map(int, input().split())

x = []

for i in range(10+1):
    x.append(0)

x[0] = x2000
# print(x[0])

for i in range(10):
    x[i+1] = r * x[i] - d
    print(x[i+1])
Buggy code:
r, D, x2000 = map(int, input().split())
for i in range(10):
  x = r*x - D
  print(x)

Fixed code:
r,D,x = map(int,input().split())
for i in range(10):
    print(r*x-D)
    x = r*x-D
Buggy code:

r,D,x2000 = list(map(int, input().split()))

for i in  range(10):
    new =  r *x - D
    print(new)
    x = new


Fixed code:
r,D,x = list(map(int, input().split()))

for i in  range(10):
    new =  r *x - D
    print(new)
    x = new
Buggy code:
r,D,x_2000=map(int, input().split())

def calc(x):
    if x==2000:
        ans=x_2000
    else:
        ans=r*calc(x-1)-D
    return ans

for i in range(2000,2011):
  ans2=calc(i)
  print(ans2)

Fixed code:
r,D,x_2000=map(int, input().split())

def calc(x):
    if x==2000:
        ans=x_2000
    else:
        ans=r*calc(x-1)-D
    return ans

for i in range(2001,2011):
  ans2=calc(i)
  print(ans2)
Buggy code:
r,D,x=map(int,input().split())

tmp=x
for i in range(10):
  tmp=tmp*r-d
  print(tmp)

Fixed code:
r, D, x = map(int, input().split())
for i in range(10):
	x = x * r - D
	print(x)
Buggy code:
r,d,x0 = map(int,input().split())
a=[x0]

for i in range(1,11):
    a.append(r*a[i-1]-d)

for i in range(11):
    print(a[i])

Fixed code:
r,d,x0 = map(int,input().split())
a=[x0]

for i in range(1,11):
    a.append(r*a[i-1]-d)

for i in range(1,11):
    print(a[i])
Buggy code:
N, M  = map(int,input().split())
As = sorted(list(map(int,input().split())))
di = {}
for i in range(b):
    b, c = map(int,input().split())
    di[c] = di.get(c, 0) + b

keys = list(sorted(di.keys(), reverse=True))
ichi = 0
for i in range(N):
    try:
        if keys[ichi] > As[i]:
            As[i] = keys[ichi]
            di[keys[ichi]] -= 1
        else:
            break
        if di[keys[ichi]] == 0:
            ichi += 1
    except:
        pass
print(sum(a))


Fixed code:
N, M  = map(int,input().split())
As = sorted(list(map(int,input().split())))
di = {}
for i in range(M):
    b, c = map(int,input().split())
    di[c] = di.get(c, 0) + b

keys = list(sorted(di.keys(), reverse=True))
ichi = 0
for i in range(N):
    try:
        if keys[ichi] > As[i]:
            As[i] = keys[ichi]
            di[keys[ichi]] -= 1
        else:
            break
        if di[keys[ichi]] == 0:
            ichi += 1
    except:
        pass
print(sum(As))