Problem:
 Score : 200 points    Problem Statement The development of algae in a pond is as follows.  Let the total weight of the algae at the beginning of the year i be x_i gram. For i≥2000 , the following formula holds:   x_{i+1} = rx_i - D   You are given r , D and x_{2000} . Calculate x_{2001} , ... , x_{2010} and print them in order.      Constraints  2 ≤ r ≤ 5  1 ≤ D ≤ 100  D < x_{2000} ≤ 200  All values in input are integers.         Input Input is given from Standard Input in the following format:  r  D  x_{2000}       Output Print 10 lines. The i -th line ( 1 ≤ i ≤ 10 ) should contain x_{2000+i} as an integer.        Sample Input 1 2 10 20      Sample Output 1 30
50
90
170
330
650
1290
2570
5130
10250  For example, x_{2001} = rx_{2000} - D = 2 \times 20 - 10 = 30 and x_{2002} = rx_{2001} - D = 2 \times 30 - 10 = 50 .       Sample Input 2 4 40 60      Sample Output 2 200
760
3000
11960
47800
191160
764600
3058360
12233400
48933560

Solution (Python):
a = input().split()
r = int(a[0])
d = int(a[1])
x = int(a[2])
for i in range(10):
  x = r*x-d
  print(x)

Solution (Python):
r,d,x=map(int,input().split())
next=0
now=x
for i in range(10):
    next=r*now-d
    print(r*now-d)
    now=next

Solution (Python):
isstr=input()
r,d,x = [int(i) for i in isstr.split(' ')]

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

Solution (Python):

import sys;
sys.setrecursionlimit(20000) 






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

















def doit(r, d, x, n):
  for i in range(10):
    x = r * x - d
    print(x)
    
  
try:
  doit(r, d, x, 0)
except Exception as e:
  print(e, file=sys.stderr)

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

Solution (Python):
r,d,x = map(int,raw_input().split())

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

Solution (Python):





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

if __name__ == '__main__':
    main()

Solution (Python):
def main():
    r,d,x=list(map(int,input().split(' ')))
    for i in range(1,11):
        x = r*x-d
        print(x)
if __name__ =='__main__':
    main()

Solution (Python):
r, d, x = [int(_) for _ in input().split()]
for i in range(10):
    x = r*x - d
    print(x)

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

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

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

a = r*x - D
b = r*a - D 
c = r*b - D
d = r*c - D
e = r*d - D
f = r*e - D
g = r*f - D
h = r*g - D
i = r*h - D
j = r*i - D

print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
print(g)
print(h)
print(i)
print(j)

Solution (Python):
a, b, c = map(int, input().split())

res = c * a - b
print(res)

for i in range(9):
	res = res * a - b
	print(res)

Solution (Python):
r, D, x2000 = map(int, input().split(' '))

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

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

xi = x2000

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

Solution (Python):
r,D,x0=map(int,input().split())
x1=r*x0-D
x2=r*x1-D
x3=r*x2-D
x4=r*x3-D
x5=r*x4-D
x6=r*x5-D
x7=r*x6-D
x8=r*x7-D
x9=r*x8-D
x10=r*x9-D
print(x1)
print(x2)
print(x3)
print(x4)
print(x5)
print(x6)
print(x7)
print(x8)
print(x9)
print(x10)

Solution (Python):



def placingMarbles(input_str):
    vals = input_str.split(" ")
    r = int(vals[0])
    D = int(vals[1])
    x_i = int(vals[2])

    for i in range(10):
        x_i = xinext(r, x_i, D)
        print(x_i)

def xinext(r, xi, D):
    return r * xi - D

if __name__ == "__main__":
    placingMarbles(input())

Solution (Python):
x = list(map(int, input().split()))
r, D, t = x[0],x[1],x[2]
def x_next(r,D,t):
    return r*t-D
for i in range(10):
    t = x_next(r,D,t)
    print(t)

Solution (Python):
r, D, x = map(int, input().split())
res = (r * x) - D
l = [res]
for i in range(9):
    rep = r * l[-1] - D
    l.append(rep)
for j in l:
    print(j)

Solution (Python):
def calcNext(r, D, x):
    return r * x - D

r, D, x = map(int, input().split())
for x_ in range(0, 10):
    x = calcNext(r, D, x)
    print(x)

Solution (Python):
a=[]
a=input().split(" ")
r=int(a[0])
D=int(a[1])
x=int(a[2])

p0=r*x-D
print(p0)
p1=r*p0-D
print(p1)
p2=r*p1-D
print(p2)
p3=r*p2-D
print(p3)
p4=r*p3-D
print(p4)
p5=r*p4-D
print(p5)
p6=r*p5-D
print(p6)
p7=r*p6-D
print(p7)
p8=r*p7-D
print(p8)
p9=r*p8-D
print(p9)

Solution (Python):
l=input().split()
list_ans=[]
A=int(l[0])*int(l[2])-int(l[1])
list_ans.append(A)
for i in range(9):
	B=int(l[0])*int(list_ans[-1])-int(l[1])
	list_ans.append(B)
for j in list_ans:
	print(j)

Solution (Python):
x_array = []
r,D,x = (int(i) for i in input().split())
x_array.append(x)
for j in range (10):
    x_array.append(r*x_array[j]-D)
    print(x_array[j+1])

Solution (Python):

r, d ,x = map(int, input().split())
"""
r = 2
d = 10 
x = 20
"""

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

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

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

Solution (Python):
r, D, x = map(int, input("").split(" "))

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

Solution (Python):
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))

Solution (Python):


import sys

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    x = [0] * 11
    r, D, x[0] = i2nn()
    for i in range(10):
        x[i + 1] = r * x[i] - D
        print(x[i + 1])
    return

main()

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

tmp = x

for _ in range(10):
    tmp = r * tmp - D
    print(tmp)

Solution (Python):
def main():
    r, d, x = map(int, input().split())
    for _ in range(10):
        x = x * r - d
        print(x)

main()

Solution (Python):
a = list(map(int, input().split()))
x = a[2]
for i in range(10):
    x = x * a[0] - a[1]
    print(x)

Solution (Python):
inputs = input().split()

r = int(inputs[0])
D = int(inputs[1])
x_2000 = int(inputs[2])

prevX = x_2000

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

Solution (Python):



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

num_list = [r * x - d]

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

Solution (Python):
r, d, x = map(int, input().split())
result = 0
rx = 0
for i in range(10):
    if i == 0:
        result = r * x - d
    else:
        result = r * result - d
    print(result)

Solution (Python):
r, d, x = map(int, input().split())
y = []
for i in range(10):
    kekka = r * x -d
    y.append(kekka)
    x = kekka
    print(kekka)

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

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

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

Solution (Python):
r, D, x = map(int, input().split())
tmp = x * r - D

for i in range(0, 10):
    print(tmp)
    tmp = tmp * r - D

Solution (Python):
r,d,x = (int(i) for i in input().split())

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

Solution (Python):
R,D,X = map(int,input().split(" "))
ans = 0

for i in range(10):
	ans = R*X-D
	X = ans
	print(ans)

Solution (Python):
lst=[0]*11
r,d,x=map(int,input().split())
lst[0]=x
for i in range(1,11):
  lst[i]=lst[i-1]*r-d
for i in range(1,11):
  print(lst[i])

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

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

Solution (Python):




S = input().split()

r = int(S[0])
D = int(S[1])
X = int(S[2])

ans = X

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

Solution (Python):
x = input()
li = x.split()
r = int(li[0])
d = int(li[1])
i = int(li[2])

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

Solution (Python):
r, D, ans = map(int,input().split())

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

Solution (Python):
r,D,x = map(int,input().split())
X = [0,0,0,0,0,0,0,0,0,0,0]
X[0] = r*x - D
for i in range(10):
    X[i+1] = r*X[i] - D
for j in range(10):
    print(X[j])

Solution (Python):
A,B,C=map(int,input().split())
ans=C
for i in range(10):
    ans=ans*A-B
    print(ans)

Solution (Python):
r, D, x = list(map(int, input().split(' ')))

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

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

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

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

Solution (Python):



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

xnext = xstart

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

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

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

Solution (Python):
r,d,x2000 = map(int,input().split())
a=[x2000]
for x in range(10):
    a.append(int(a[x])*r-d)

for x in range(10):
    print(a[x+1])

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

Solution (Python):
Rs,Ds,Xs=input().split()
R=int(Rs)
D=int(Ds)
X=int(Xs)

for i in range(10):
	X=R*X-D
	print(X)

Solution (Python):
r, D, x2000 = map(int, input().split())
count = 0
def mo(suu, count):
    suu2 = suu * r - D
    print(suu2)
    count2 = count +  1
    if count < 9:
        mo(suu2, count2)


mo(x2000, count)

Solution (Python):
r,d,x = [int(i) for i in input().split()]
for i in range(10):
  x = r*x-d
  print(str(x))

Solution (Python):
r, D, x2000 = map(int, input().split())

x = []
x.insert(0, x2000)
for i in range(1, 11):
	x.insert(i, r * x[i-1] - D)

for i in range(1, 11):
	print(x[i])

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

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

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

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

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

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

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

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


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

Solution (Python):
r,d,x=map(int,input().split())
a=r*x-d
b=r*a-d
c=r*b-d
e=r*c-d
f=r*e-d
g=r*f-d
h=g*r-d
i=h*r-d
j=r*i-d
k=r*j-d
print(int(a))
print(int(b))
print(int(c))
print(int(e))
print(int(f))
print(int(g))
print(int(h))
print(int(i))
print(int(j))
print(int(k))

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

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

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

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

Solution (Python):
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)

Solution (Python):
from sys import stdin
import numpy as np

r, D, x2000 = [int(x) for x in stdin.readline().rstrip().split()]

x = x2000

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

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

Solution (Python):


import sys
a = list(map(int, input().split()))

def recurciv(a0,a1,x,c):
    c+=1
    x=a0*x-a1
    print(x)
    if c==10:
        sys.exit()
    else:
        recurciv(a0,a1,x,c)

"""
x2001=a[0]*a[2]-a[1]
print(x2001)
x2002=a[0]*z2001-a[1]
"""
recurciv(a[0],a[1],a[2],0)

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

weight = r*x-D
for i in range(2, 12):
    print(weight)
    weight = r*weight-D

Solution (Python):
n = list(map(int, input().split()))

r = n[0]
d = n[1]
x = n[2]

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

Solution (Python):

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

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

Solution (Python):
def f(x,r,d):
    return r*x-d

r,d,x=[int(i) for i in input().split()]
mem=x
for i in range(10):
    mem=f(mem,r,d)
    print(mem)

Solution (Python):
r, D, x =  input().split()
r = int(r)
D = int(D)
x = int(x)

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

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


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

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

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

Solution (Python):
r,D,x =map(int,input().split())
a=[]
for i in range(10):
    x =r*x-D
    print(x)

Solution (Python):


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

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

Solution (Python):
from sys import stdin

def calc(r, D, x):
  y = r*x - D
  return y
  
def main():
    r, D, x_2000 = map(int, stdin.readline().rstrip().split())
    y=x_2000
    for i in range(10):
      y = calc(r, D, y)
      print(y)

input = lambda: stdin.readline()
main()

Solution (Python):
r,d,x = map(int,input().split())
ans = 0
for i in range(10):
  ans = r*x-d
  print(ans)
  x = ans

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

Solution (Python):
if __name__ == '__main__':
    r, D, x2000 = map(int, input().split())

    x = x2000

    for i in range(2001, 2011):
        x = r * x - D
        print(str(x))

Solution (Python):




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

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

Solution (Python):
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]

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

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

Solution (Python):


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

l = [0] * 11
l[0] = x2000
for i in range(1,11):
    l[i] = r * (l[i - 1]) - D
    
for i in range(1, 11):
    print(l[i])

Solution (Python):
r, D , x = input().split()
r = int(r)
D = int(D)
x = int(x)

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

Solution (Python):
r,d,x=map(int,input().split())
for n in range(10):
    x=r*x-d
    print(x)

Solution (Python):
r,d,x=map(int,input().split())
xli=[x]
for i in range(10):
    xli.append(xli[i]*r-d)
    print(xli[i+1])

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

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

Solution (Python):
a,b,c=map(int,input().split())

for i in range(10):
  answer = a*c-b;
  print(answer)
  c = answer

Solution (Python):
r,d,x=input().split()
r=int(r)
d=int(d)
x=int(x)
i=0
while i!=10:
    i=i+1
    x=x*r-d
    print(x)

Solution (Python):
a,b,c = map(int, input().split())
def calc_mo(x):
    x = a * x - b
    return x

for i in range(1, 11):
    if i == 1:
        x = c
    x = calc_mo(x)
    print(x)

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

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

Solution (Python):
number = input().split()
answer = 0
answer_list = []


answer = int(number[0]) * int(number[2]) - int(number[1])
print(answer)

for i in range(9):
    answer = int(number[0]) * answer - int(number[1])
    print(answer)

Solution (Python):
import sys
r,d,xc = map(int, input().split())
for i in range(10):
    xc = r*xc-d
    print(int(xc))

Solution (Python):
r, D, x_2000 = map(int, input().split(" "))
x = x_2000
for i in range(1, 11):
    x = r * x - D
    print(x)

Solution (Python):
r,d,x = map(int,input().split())
LI = [x]
for i in range(10):
    A = r * LI[i] - d
    LI.append(A)
    print(LI[i+1])

Solution (Python):
r, d, i = map(int, input().split())

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

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

for i in range(2001, 2011):
    x = r * x - D
    print(x)

Solution (Python):
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])

Solution (Python):
r,d,x = (int(i) for i in input().split())

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

Solution (Python):
r, D, x0 = map(int, input().split())
xi = x0
for i in range(10):
    x = r*xi - D
    xi = x
    print(x)

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

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

Solution (Python):


r,d,x_2000=map(int, input().split())
x_i=[0]*10

for ii in range(0,10):
    if ii == 0:
        x_i[ii] = r * x_2000 - d
    else :
        x_i[ii] = r * x_i[ii-1] - d
    print(x_i[ii])

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

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

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

Solution (Python):
r,d,x = map(int, input().split())
i = 1
while i <=10:
  x = r * x -d
  print(x)
  i += 1

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

Solution (Python):
r,d,x_ini=map(int,input().split())
x=x_ini
for i in range(10):
    print(x*r-d)
    x=x*r-d

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

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

Solution (Python):
def operation(r, x_i, d):
  return (r*x_i)-d
  
r, d, x_i = map(int, input().split())
for i in range(10):
  x_i = operation(r, x_i, d)
  print(x_i)

Solution (Python):
r,d,x = map(int, input().split())
ans = 0

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

Solution (Python):

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

for _ in range(1, 11):
    x = r * x - d
    print(x)

Solution (Python):
r, D, X2000 = map(int, input().split())
tmp = r * X2000 - D
for i in range(10):
    print(tmp)
    tmp = r * tmp - D

Solution (Python):
r, D, x_s = [int(item) for item in input().split()]
for i in range(10):
  x_s = r*x_s - D
  print (x_s)

Solution (Python):

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

Solution (Python):
data = list(map(int,input().split()))
for i in range(2001,2011):
    data[2] = data[0]*data[2]-data[1]
    print(data[2])

Solution (Python):


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

Solution (Python):
r,d,x = list(map(int,input().split()))
lis = []
for i in range(10):
    if i ==0:
        lis.append(r*x-d)
    else:
        lis.append(r*lis[i-1]-d)
    print(lis[i])

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

Solution (Python):
r, D, x2000 = map(int, input().split())
for i in range(10):
  x2000 = r * x2000 - D
  print(x2000)

Solution (Python):
r, D, X = map(int, input().split())

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

Solution (Python):
r,D,x2000 = map(int,input().split())

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

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

Solution (Python):
r,D,x_2000=input().split()

r = int(r)
D = int(D)
x_2000 = int(x_2000)

for i in range(10):

    x_2001 = r * x_2000 - D
    print(x_2001)
    x_2000 = x_2001

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

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

Solution (Python):
def main():
    r, D, x = map(int, input().split())
    for i in range(10):
        x = r * x - D
        print(x)


if __name__ == '__main__':
    main()

Solution (Python):
if __name__ == '__main__':
    s = input().rstrip().split(' ')
    r = int(s[0])
    D = int(s[1])
    xinit = int(s[2])

    x = xinit

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

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

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

Solution (Python):
a, b, c = map(int, input().split())
count = 0
ans = c
while count < 10:
    c = a * c - b
    count = count +1
    print(int(c))

Solution (Python):

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

ans = []

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

Solution (Python):
r, D, x = map(int, input().split())
x_list = [x]

for i in range(10):
    next_x = r * x_list[i] - D
    x_list.append(next_x)
    print(next_x)

Solution (Python):
r, d, x = map(int, input().split())
count = 9
ans = r * x - d
print(ans)
while count != 0:
    ans = r * ans -d
    print(ans)
    count -= 1

Solution (Python):
r,D,x = map(int,input().split())
for i in range(1,11):
 x=r*x-D
 print(x)

Solution (Python):
r, D, x0 = map(int, input().split())

x = x0

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

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

Solution (Python):
a, b, c = map(int, input().split())
ret = c
for i in range(10):
  ret = a*ret-b
  print(ret)

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

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

Solution (Python):
a, b, c = map(int, input().split())

x1 = a*c - b
print(x1)
x2 = a*x1 - b
print(x2)
x3 = a*x2 - b
print(x3)
x4 = a*x3 - b
print(x4)
x5 = a*x4 - b
print(x5)
x6 = a*x5 - b
print(x6)
x7 = a*x6 - b
print(x7)
x8 = a*x7 - b
print(x8)
x9 = a*x8 - b
print(x9)
x10 = a*x9 - b
print(x10)

Solution (Python):
def algae(r, D, x):
    x = x
    for _ in range(10):
        x = r*x-D
        print(x)


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

Solution (Python):



def calc(rate, diff, v, counter, lst):
    if counter >= 2010:
        return lst
    next = rate * v - diff
    lst.append(next)
    return calc(rate, diff, next, counter + 1, lst)


r, d, x_2000 = [int(x) for x in input().rstrip().split(" ")]
result = calc(r, d, x_2000, 2000, [])
print("\n".join([str(x) for x in result]))

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


def koke(i, r, D, x):
    if i == 10:
        return 0
    w = r * x - D
    print(w)
    i += 1
    koke(i, r, D, w)


koke(0, r, D, x)

Solution (Python):
r,D,x_2000=map(int,input().split())
def Algae(r,D,x):
    weight=[]
    for _ in range(10):
        x=r*x-D
        weight.append(x)
    return weight

for i in Algae(r,D,x_2000):
    print(i)

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

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

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

Solution (Python):
r, d, x = map(int, input().split())
l = [x]
for i in range(10):
    l.append(l[-1] * r - d)
del l[0] 

print(*l, sep="\n")

Solution (Python):

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

Solution (Python):
import sys
from fractions import gcd

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()
s = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]



r, d, x = na()

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

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

arr = []

arr.append(x)
for i in range(10):
    arr.append(r * arr[i] - d)

for i in range(10):
    print(arr[i + 1])

Solution (Python):
r,d,x = map(int, input().split())
ans =[x]

for i in range(10):
  ans.append(r*ans[i]-d)
  print(ans[i+1])

Solution (Python):
li = list(map(int,input().split()))
r = li[0]
D = li[1]
x = li[2]
for i in range(10):
	x = r*x - D
	print(x)

Solution (Python):


v = [int(d) for d in input().split()]
kako = v[2]

for k in range(10):
    print(kako*v[0]-v[1])
    kako = kako*v[0]-v[1]

Solution (Python):
s = list(map(int,input().split()))
r = s[0]
d = s[1]
x = s[2]

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

Solution (Python):
r, D, x0 = map(int, input().split())
x = x0
for i in range(10):
    E = r * x - D
    print(E)
    x = E

Solution (Python):
def next(r, D, x_before):
	return r*x_before - D

inputs = list(map(int, input().split(' ')))[:3]
r = inputs[0]
D = inputs[1]
x2000 = inputs[2]

x_cur = next(r,D,x2000)

for i in range(1,11):
	print(x_cur)
	x_cur = next(r,D,x_cur)

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

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

Solution (Python):
r, D, x_2000 = map(int, raw_input().split())
x_list = [0] * 11
x_list[0] = x_2000

def output(r, D, x):
    x_plus = r * x - D
    return x_plus

for i in range(10):
    x_list[i+1] = output(r, D, x_list[i])
    print x_list[i+1]

Solution (Python):
r,D, x_2000 = map(int,input().split())


def add(x):
    a = r * x - D
    return a

x_2001 = add(x_2000)
x_2002 = add(x_2001)
x_2003 = add(x_2002)
x_2004 = add(x_2003)
x_2005 = add(x_2004)
x_2006 = add(x_2005)
x_2007 = add(x_2006)
x_2008 = add(x_2007)
x_2009 = add(x_2008)
x_2010 = add(x_2009)

print(x_2001)
print(x_2002)
print(x_2003)
print(x_2004)
print(x_2005)
print(x_2006)
print(x_2007)
print(x_2008)
print(x_2009)
print(x_2010)

Solution (Python):
a = list(map(int,input().split()))
x = [a[2]]*11
for i in range(1,11):
        x[i] = (x[i-1]*a[0]) - a[1]
for j in range(1,11):
        print(x[j])

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

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

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

Solution (Python):
r,D,x=map(int,input().split())
xa=[x]
ans=0
for i in range(0,10):
    xa.append(r*xa[i]-D)
    print(xa[i+1])

Solution (Python):
r, D, x = map(int, input().split())
def mo(r, D, x, i):
  out = r*x - D
  print(int(out))
  if i<9:
  	return mo(r, D, out, i+1)
  else:
    return 0
  
mo(r, D, x, 0)

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

Solution (Python):

lst_1 = input().split()

A = int(lst_1[0])
B = int(lst_1[1])
C = int(lst_1[2])

ans = 0

ans = A * C - B

for i in range(10):

    print(ans)
    ans = ans * A - B

Solution (Python):
ss=input().split(" ")
r=int(ss[0])
d=int(ss[1])
x=int(ss[2])
for i in range(10):
  x=int(r*x-d)
  print(x)

Solution (Python):
r, D, x2000 = map(int, input().split())

x1 = []

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

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

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

  print(x)

Solution (Python):
string_list=list(map(int,input().split()))
r=string_list[0]
D=string_list[1]
x_2000=string_list[2]
def calculate_next(x):
    return x*r-D


x_next = x_2000
for i in range(10):
    x_next=calculate_next(x_next)
    print(x_next)

Solution (Python):
r, D, x = map(int, input().split())
count = 0

for i in range(10):
    if count == 0:
        print(r*x-D)
        count = r*x-D
    else:
        print(r*count-D)
        count = r*count-D

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

c=x
for i in range(11):
    if not(i==0):
      res=r*c-d
      c=res
      print(res)

Solution (Python):
a = input().split()
r = int(a[0])
d = int(a[1])
x = int(a[2])

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

Solution (Python):
(r, D, x) = (int(i) for i in input().split(' '))
for i in range(0,10):
    x = r * x - D
    print(x)

Solution (Python):
r,d,x = map(int, input().split())
tmp = [x]
for i in range(1,11):
    tmp.append(tmp[i-1] * r - d)

del tmp[0]

for i in tmp:
    print(i)

Solution (Python):
r,D,x = list(map(int,input().split()))
x_list = [x]

for i in range(10):
  next = x_list[i]*r-D
  x_list.append(next)
  
for i in range(10):
  print(x_list[i+1])

Solution (Python):
r,d,x = map(int,input().split())
a=0

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

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

Solution (Python):
a, b, c = map(int, input().split(" "))

for co in range(10):
    c = c * a - b
    print(c)

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

Solution (Python):



def solv(r, d, x):
    ans = []

    for y in range(2001, 2011):
        x = r * x - d
        ans.append(str(x))
    return "\n".join(ans)


if __name__ == '__main__':

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

    ans = solv(r, d, x)

    print(ans)

Solution (Python):
r, d, x2000 = map(int, input().split())

x = []

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

x[0] = x2000


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

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

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

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

a = [0 for i in range(11)]
a[0] = x_2000
for i in range(10):
    a[i+1] = r * a[i] - d

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

Solution (Python):
r, d, x = map(int,input().split())
after = r * x - d
for i in range(1,11):
    print(after)
    after = r * after - d

Solution (Python):
r, D, x2000 = map(int, input().split())

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

Solution (Python):
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))

Solution (Python):
argR,argD,argX2000 = list(map(int,input().split()))

wk = argX2000
for i in range(10):
  wk = wk * argR - argD
  print(wk)

Solution (Python):
d = input().split(" ")
r = int(d[0])
D = int(d[1])
x_i = int(d[2])

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

Solution (Python):
r, D ,xi = map(int, input().split())

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

Solution (Python):
r,D,x2000 = map(int,input().split())

x = r*x2000 - D
for y in range(2001,2011):
	print(x)
	x = r*x - D

Solution (Python):
def read():
    r, D, x0 = list(map(int, input().strip().split()))
    return r, D, x0


def solve(r, D, x0):
    x = list()
    for i in range(10):
        x1 = r * x0 - D
        x.append(x1)
        x0 = x1
    return x


if __name__ == '__main__':
    inputs = read()
    for x in solve(*inputs):
        print("%d" % x)

Solution (Python):
r,d, x = map(int,input().split())
for i in range(10):
    n = r*x - d
    x = n
    print(n)

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

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

Solution (Python):
r, D, X = map(int, input().split())

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

Solution (Python):
r, D, x = [int(i) for i in input().split()]

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)








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

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

Solution (Python):
r,D,x = map(int,input().split())
X = []
X.append(x)

for i in range(1,11):
    result = r*X[i-1]-D
    X.append(result)

for i in range(1,11):
    print(X[i])

Solution (Python):
r, D, x0 = [int(x) for x in input().split()]

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

Solution (Python):
r ,D , x2000 = map(int, input().split())

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

Solution (Python):
r,d,x = map(int, input().split())
a = 0
for i in range(1,11):
    a=r*x-d
    print(a)
    x=a