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):



def calc(x1, r, D):
    return r * x1 - D



def main():
    r, d, x = list(map(int, input().split(" ")))
    for _ in range(10):
        x = calc(x, r, d)
        print(x)


if __name__ == '__main__':
    main()

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

total = x

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

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

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

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

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

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())

x = x2000

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

Solution (Python):
def read_input():
    a,b,c=map(int, input().split())
    if 2<=a<=5 and 1<=b<=100 and b<c<=200:
        return a,b,c
    else :
        print("Error")
        exit()

def main():
    num = 10

    r,D,x=read_input()
    sum_x=x

    for i in range(num):
        sum_x=r*sum_x-D
        print(sum_x)
        sum_x=sum_x



if __name__ == "__main__":
    main()

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

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

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

xk = x0

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

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

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

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

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

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):
    print(r*x-D)
    x = r*x-D

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

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

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

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

c = x2000
for _ in range(2001, 2010+1):
  c = r * c - D
  print(c)

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

for _ in range(0, 10):
    nx = r * x2 - D
    print(nx)
    x2 = nx

Solution (Python):
import sys
input = sys.stdin.readline

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

t = A * C - B
for i in range(1, 11):
    print(t)
    t = A * t - B

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


if __name__ == '__main__':
	main()

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

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

Solution (Python):
cmdvar=input()
in_plited=cmdvar.split()

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

i=0
while i<10:
    x_2000=r*x_2000-D
    ans=x_2000
    print(ans)
    i=i+1

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

Solution (Python):
from sys import stdin
r, d, x = [int(x) for x in stdin.readline().rstrip().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) : 
    y = r*x -D
    print(y)
    x = y

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

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

Solution (Python):






import sys

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())
x_list = []
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())
for _ in range(10):
  x = r*x - D
  print(x)

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

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

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

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

Solution (Python):
algae = input().split()
rate = int(algae[0])
down_weight = int(algae[1])
weight = int(algae[2])
next_weight = 0

for i in range(1, 11):
    next_weight = rate * weight - down_weight
    weight = next_weight
    print(next_weight)

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 = (int(i) for i in input().split())

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

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

Solution (Python):
def calculate(r, D, x_2000):
  result = []
  temp_result = x_2000
  for i in range(0, 10):
    temp_result = r * temp_result - D
    result.append(temp_result)
    
  return result
  
  
import sys

r=0
D=0
x_2000=0
is_arg_ok = False
try:
  num_list = input().split(' ')
  r = int(num_list[0])
  D = int(num_list[1])
  x_2000 = int(num_list[2])
  is_arg_ok = True
  
except:
  print('age,price must be numbers')
  sys.exit(1)

calculated_weights = calculate(r, D, x_2000)
for weignt in calculated_weights:
  print(weignt)
sys.exit(0)

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

Solution (Python):
r,d,a=map(int,input().split())
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):
  print(r*x-d)
  x=(r*x-d)

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 = x
for _ in range(10):
    result = r * result - d
    print(result)

Solution (Python):
r, d, x = map(int, input().split())
for _ in range(10):
    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())
X=[0]*10
X[0]=r*x-D
print(X[0])
for i in range(9):
  X[i+1]=X[i]*r-D
  print(X[i+1])

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

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

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

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

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



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

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

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

Solution (Python):
r, D, x = [int(i) for i in 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):
  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 _ 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())

ans = x
for _ in range(1, 10 + 1):
    ans = r * ans - D
    print(ans)

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

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

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

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

Solution (Python):
r, D, a0 = map(int, input().split())
d = -D/(1-r)
for n in range(1, 11):
    ans = d+(r**n)*(a0-d)
    ans = int(ans)
    print(ans)

Solution (Python):

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

r = int(r)
D = int(D)
x = int(x)

now_x = x

for i in range(10):
    now_x = r*now_x - D
    print (now_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())

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

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())
for i in range(10):
    print(r * x - D)
    x = r * x - D

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):
def cal_algae(r, d, x, i):
    if i < 2010:
        x = r * x - d
        print(x)
        cal_algae(r, d, x, i + 1)


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

i = 2000

cal_algae(r, d, x, i)

Solution (Python):
def cal_algae(r, d, x, i):
    if i < 2010:
        x = r * x - d
        print(x)
        cal_algae(r, d, x, i + 1)


algae = list(map(int, input().split()))

r = int(algae[0])
d = int(algae[1])
x = int(algae[2])

i = 2000

cal_algae(r, d, x, i)

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

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

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

x = x2000
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):
N = [int(i) for i in input().split()]
for i in range(10):
    sum = N[0] * N[2] - N[1]
    N[2] = sum
    print(sum)

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):
a,b,c = map(int,input().split())
for i in range(10):
  c = a*c-b
  print(c)

Solution (Python):
import numpy as np



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



X = x_2000

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

Solution (Python):



import math
import statistics


def fact(n):
  if(n == 1):
    return 1
  else:
    return (n * fact(n - 1))


def gcd(a,b):
  if a == 0:
    return b
  elif b == 0:
    return a
  else:
    return gcd(b,a % b)


def lcm(a,b):
  return (a * b / gcd(a,b))


def qsort(seq):
  if len(seq) < 1:
      return seq
  pivot = seq[0]
  left = []
  right = []
  for x in range(1, len(seq)):
    if seq[x] <= pivot:
        left.append(seq[x])
    else:
        right.append(seq[x])
  left = qsort(left)
  right = qsort(right)
  foo = [pivot]
  return (left + foo + right)



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

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

Solution (Python):
def main():
    r, d, current_x = [int(x) for x in input().rstrip().split(" ")]

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


if __name__ == '__main__':
    main()

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

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):
    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_0 = map(int,input().split())

x = [x_0]

def x_(r,elem,D):
    return r*elem - D

for i in range(10):
    x.append(x_(r,x[i],D))
for i in range(1,11):
    print(x[i])

Solution (Python):
r,d,x = map(int, input().split())
A = [x]
B = []
for i in range(10):
    A.append(r*A[i]-d)
    B.append(r*A[i]-d)
print(*B, sep = '\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_2000 = map(int, input().split())
x = x_2000
for i in range(10):
  x = r * x - d
  print(x)

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

def saiki(x):
    return r*x - D

now = x2000
for i in range(10):
    x = saiki(now)
    print(x)
    now = x

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

Solution (Python):
INPUT = input().split()
r = int(INPUT[0])
D = int(INPUT[1])
X = int(INPUT[2])

XX = []

ans = ""
XX.append(X)

i = 0
while i < 10:
    v = r * XX[i] - D
    XX.append(v)
    ans = ans + str(XX[i + 1]) + '\n'
    i += 1

print(ans)

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):
    x = (r*x) - D
    print(x)

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

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

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

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().rstrip().split())

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

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

for i in range(10):
    print(func(r,D,x))
    x = func(r,D,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(r*x-d)
  x=r*x-d

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_2000 = map(int, input().split())
for i in range(10):
    x_next = r * x_2000 - D
    print(x_next)
    x_2000 = x_next

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):
r,d,x = map(int, input().split())

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

Solution (Python):
l = input().split()
r = int(l[0])
d = int(l[1])
x = int(l[2])
for i in range(0, 10):
    x = r * x -d
    print(int(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())

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

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

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

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

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

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

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

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

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


def answer(r, d, x):
    return r*x - D


for i in range(10):
    x = answer(r, D, x)
    print(x)

Solution (Python):
r, d, x = map(int, input().split())
answerL=[]
index=0
while index < 10:
    newX = r*x-d
    answerL.append(newX)
    x = newX
    index+=1
for answer in answerL:
    print(answer)

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

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

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

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 = list(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,input().split())
x_ = x_2000

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

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 = [int(i) for i in input().split()]

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

Solution (Python):
r, D, x = [int(x) for x in 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):
    x = r * x - d
    print(int(x))

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


def solve(r, d, x2000):
    x_prev = x2000
    x_list = []
    for i in range(10):
        x = r * x_prev - d
        x_list.append(x)
        x_prev = x
    return x_list


def main():
    r, d, x2000 = input_from_console()
    x_list = solve(r, d, x2000)
    print('\n'.join(map(str, x_list)))


if __name__ == "__main__":
    import sys
    if sys.gettrace():  
        check_cases()
    else:
        main()

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())
y=0
for i in range(10):
    y=r*x - d
    print(y)
    x = y

Solution (Python):
r, D, x = map(int, input().split())
for a 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 algae(r,d,x):
    for i in range(10):
        x = r*x-d
        print(x)    
r,d,x = map(int, input().split())
algae(r,d,x)

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

ans = []

for i in range(10):
        x = r * x - d
        ans.append(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 = map(int, input().split())
xs = [x]
for i in range(10):
    xs.append(xs[-1] * r - d)
print("\n".join(map(str, xs[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 = 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())
for i in range(10):
    x = r * x - d
    print(int(x))

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

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

r = int(rdx[0])
d = int(rdx[1])
x = int(rdx[2])

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

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

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


def a():
    n = x
    while True:
        num = r * n - d
        yield num
        n = num


gen = a()
for i in range(10):
    num = next(gen)
    print(num)

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

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

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())
for k in range(10):
  x = r*x -d
  print(x)

Solution (Python):


r,d,x=map(int,raw_input().split())
i=10
while i:
 res=r*x-d
 print res
 x=res
 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 = [int(t) for t in input().split()]
ans = x
for i in range(10):
    ans = r*ans - D
    print(ans)

Solution (Python):
r, D, x_2000= map(int, input().split(' '))
xs = [x_2000]
for x in range(10):
	xs.append(r*xs[len(xs)-1]-D)
xs.pop(0)
print('\n'.join(map(str, xs)))

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


def solve(r, d, x2000):
    x_prev = x2000
    x_list = []
    for i in range(10):
        x = r * x_prev - d
        x_list.append(x)
        x_prev = x
    return x_list


def main():
    r, d, x2000 = input_from_console()
    x_list = solve(r, d, x2000)
    print('\n'.join(map(str, x_list)))

if __name__ == "__main__":
    DEBUG = False
    if not DEBUG:
        main()

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

for i in range(10):

    x = x *r -D
    print(x)

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

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

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

L = [x2000]

for i in range(10) :
    calc = r*L[-1] - D
    L.append(calc)

print(*L[1:], sep="\n")

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

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

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

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

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 = list(map(int, input().rstrip().split()))
for i in range(10):
    x = r * x - d
    print(x)

Solution (Python):
r, D, x = [int(s) for s in 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):
  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 = list(map(int, input().split()))
for i in range(10):
    x = r * x - d
    print(x)

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

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

Solution (Python):
R, D, X2000 = [int(i) for i in input().split()]
ans = [R * X2000 - D]
for _ in range(9):
    ans.append(R * ans[-1] - D)
print('\n'.join(map(str, ans)))

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

Solution (Python):
def abc127b():
    r, D, x2k = (int(s) for s in input().split(" "))
    x = x2k
    for n in range(2001, 2011):
        x = r * x - D
        print(x)
def main():
    abc127b()
main()

Solution (Python):
r, D, x = list(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):



def solve(r, D, x_2000):
    temp = x_2000
    for i in range(2001, 2010+1):
        temp = r * temp - D
        print(temp)
        


def main():
    r, D, x_2000 = map(int, input().split())
    solve(r, D, x_2000)
    
    pass

if __name__ == '__main__':
    main()

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

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

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

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

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 = [int(n) for n in input().split()]
for i in range(10):
  print(r*x - D)
  x = r*x - D

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(x)

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

def f(x):
    return r*x - d
  
if __name__=="__main__":
    xii = xi
    for _ in range(10):
        xii = f(xii)
        print(xii)

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

Solution (Python):
r, D, x = map(int, input().split())
for i in range(0, 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, init = map(int, input().split())
for i in range(10):
  ans = init*r - D
  print(ans)
  init = ans

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

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):
import sys

r, D, x2000 = map(lambda x: int(x), sys.stdin.readline().split(" "))

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

Solution (Python):
r,d,x=map(int,input().split());exec('x=r*x-d;print(x);'*10)

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

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

Solution (Python):
r,d,x=map(int,input().split());exec('x=r*x-d;print(x);'*10)

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 = [int(i) for i in input().split()]
for i in range(10):
    x = r*x -d
    print(x)

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

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())
x2001 = r * x - D
x2002 = r * x2001 - D
x2003 = r * x2002 - D
x2004 = r * x2003 - D
x2005 = r * x2004 - D
x2006 = r * x2005 - D
x2007 = r * x2006 - D
x2008 = r * x2007 - D
x2009 = r * x2008 - D
x2010 = r * x2009 - D
print(x2001)
print(x2002)
print(x2003)
print(x2004)
print(x2005)
print(x2006)
print(x2007)
print(x2008)
print(x2009)
print(x2010)

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

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

for i in range(1,11):
    c *= a
    c -= b
    print(c)

Solution (Python):
r, D, x2000 = map(int, input().split())
lst = []
prev = x2000
for _ in range(10):
    ans = r * prev - D
    lst.append(ans)
    prev = ans

for i in lst:
    print(i)

Solution (Python):
import sys

def main():
    r,D,x2k=input().split()

    moGram(r,D,x2k,2010)


def moGram(r, D, x2k, i) :

    if i == 2000 :
        return x2k
    else :
        oldGram = moGram(r, D, x2k, i-1) 
        gram = int(r)*int(oldGram) - int(D)
        print(gram)
        return gram

main()

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

Solution (Python):

import sys

def solve(r: int, D: int, x: int):
    arr = []
    arr.append(x)
    for i in range(10):
        arr.append(r * arr[i] - D)
        print(arr[i + 1])
    



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    r = int(next(tokens))  
    D = int(next(tokens))  
    x = int(next(tokens))  
    solve(r, D, x)



if __name__ == '__main__':
    main()

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=[0]*11
a[0]=x
for i in range(1,11):
  a[i]=r*a[i-1]-d
for i in range(1,11):
  print(a[i])

Solution (Python):
import sys

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

x = a*c -b

for i in range(0,10):	
	print(x)
	x = a*x-b

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=input().split()
r=int(R)
d=int(D)
x0=int(X)
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):
r, D, x = map(int, input().split())
2<=r<=5
1<=D<=100
D<=x<=200
i = 1

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

Solution (Python):
R, D, X =  list(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())

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

Solution (Python):

r,D,s=map(int,input().split())
x =[0 for i in range(11)]
x[0]=s

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

Solution (Python):
def spaceinput():
    return list(map(int,input().split(" ")))

r,D,xx=spaceinput()

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

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

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

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

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())
for _ in range(10):
	x=r*x-d
	print(x)