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







import sys
sys.setrecursionlimit(10**7)
from itertools import accumulate, combinations, permutations 
from math import factorial
def combinations_count(n, r):
    
    
    
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n
    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]
    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot
    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])
    return result
def combination_with_repetition_count(n, r):
    return combinations_count(n + r - 1, r)
from collections import deque, Counter 
from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest 
from copy import deepcopy, copy 
from operator import itemgetter 


from functools import reduce
from fractions import gcd 
def gcds(numbers):
    return reduce(gcd, numbers)
def lcm(x, y):
    return (x * y) // gcd(x, y)
def lcms(numbers):
    return reduce(lcm, numbers, 1)



INF = 10 ** 18
MOD = 10 ** 9 + 7
modpow = lambda a, n, p = MOD: pow(a, n, p) 
def modinv(a, p = MOD):
    
    
    return modpow(a, p-2, p)
def modinv_list(n, p = MOD):
    if n <= 1:
        return [0,1][:n+1]
    else:
        inv_t = [0,1]
        for i in range(2, n+1):
            inv_t += [inv_t[p % i] * (p - int(p / i)) % p]
        return inv_t
def modfactorial_list(n, p = MOD):
    if n == 0:
        return [1]
    else:
        l = [0] * (n+1)
        tmp = 1
        for i in range(1, n+1):
            tmp = tmp * i % p
            l[i] = tmp
        return l
def modcomb(n, k, fac_list = [], p = MOD):
    
    
    from math import factorial
    if n < 0 or k < 0 or n < k: return 0
    if n == 0 or k == 0: return 1
    if len(fac_list) <= n:
        a = factorial(n) % p
        b = factorial(k) % p
        c = factorial(n-k) % p
    else:
        a = fac_list[n]
        b = fac_list[k]
        c = fac_list[n-k]
    return (a * modpow(b, p-2, p) * modpow(c, p-2, p)) % p
def modadd(a, b, p = MOD):
    return (a + b) % MOD
def modsub(a, b, p = MOD):
    return (a - b) % p
def modmul(a, b, p = MOD):
    return ((a % p) * (b % p)) % p
def moddiv(a, b, p = MOD):
    return modmul(a, modpow(b, p-2, p))




    
    

    
    
    
    
    

    
    


r = lambda: sys.stdin.readline().strip() 
R = lambda: list(map(int, r().split())) 
Rmap = lambda: map(int, r().split())


r_, d, x = R()
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, r2000 = map(int, input().split())

for i in range(1, 11):
    print(r * r2000 - d)
    r2000 = r * r2000 - 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())
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().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):
    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):
r, D, saitama2000 = map(int, input().split())

kechadon2000 = saitama2000 * r - D
koibumi2000 = kechadon2000 * r - D
yokuderu2000 = koibumi2000 * r - D
taberuna2000 = yokuderu2000 * r - D
kitasaitama2000 = taberuna2000 * r - D
toroban2000 = kitasaitama2000 * r - D
tendiku2000 = toroban2000 * r - D
EkiBEN2000 = tendiku2000 * r - D
X_DAY2000 = EkiBEN2000 * r - D
hayasaitama2000 = X_DAY2000 * r - D

print(kechadon2000)
print(koibumi2000)
print(yokuderu2000)
print(taberuna2000)
print(kitasaitama2000)
print(toroban2000)
print(tendiku2000)
print(EkiBEN2000)
print(X_DAY2000)
print(hayasaitama2000)

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

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

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

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

x = r * x - d
print(x)
x = r * x - d
print(x)
x = r * x - d
print(x)
x = r * x - d
print(x)
x = r * x - d
print(x)
x = r * x - d
print(x)
x = r * x - d
print(x)
x = r * x - d
print(x)
x = r * x - d
print(x)
x = r * x - d
print(x)

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

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

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

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

for i in range (10) :
    num = mo(num)
    print(num)

Solution (Python):
r, D, x = list(map(int, input().split()))
count = 0
while count < 10:
    count += 1
    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 _ 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 func(r, x, d):
    return r * x - d

def main():
    r, d, x0 = map(int, input().split())

    lst = list()
    lst.append(x0)
    for i in range(0, 10):
        lst.append(func(r, lst[i], d))
    
    for it in lst:
        if (it == x0):
            continue
        print(it)
    
main()

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

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

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

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

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

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


abc()

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

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

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

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

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

x = [0]*11
x[0] = x_0
for i in range(1, 11):
    x[i] = r * x[i - 1] - d
    print(x[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_2000 = map(int, input().split())

x_i = x_2000
x_j = 0
for i in range(10):
    x_j= r * x_i - D
    x_i = x_j
    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):
def solve(string):
    r, d, x = map(int, string.split())
    ans = []
    for _ in range(10):
        x = r * x - d
        ans.append(str(x))
    return "\n".join(ans)


if __name__ == '__main__':
    print(solve(input()))

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

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

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

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

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

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,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])

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_current = x_2000

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

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

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

calu(r,D,x)

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

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

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

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

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

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

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

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

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

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

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

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

for _ in range(10):
  x = calc(r, D, x)
  print(x)

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

Solution (Python):
r_D_x2000 = input()

r = int(r_D_x2000.split(" ")[0])
D = int(r_D_x2000.split(" ")[1])
x2000 = int(r_D_x2000.split(" ")[2])

x = 0

for i in range(10):
    
    if i == 0:
        x = r * x2000 -D
        print(x)
        
    else:
        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):
li = list(map(int,input().split()))
r = li[0]
D = li[1]
x2000 = li[2]
def a(x):
  return r * x - D

for i in range(10):
  x2000 = a(x2000)
  print(x2000)

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 a[1:11]:
    print(i)

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

for i in range(10):
  print(int((x0-d/(r-1))*pow(r,i+1)+d/(r-1)))

Solution (Python):
lis1 = list(map(int,input().split()))
lis2 = [lis1[2]]
for i in range(1,11):
    lis2.append(lis1[0]*lis2[i-1]-lis1[1])
    print(lis2[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 _ in range(0, 10):
    x2000 = r*x2000-D
    print(x2000)

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

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

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

Solution (Python):

import sys
import math
import numpy as np
import itertools



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

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

Solution (Python):
a, b, c = (int(i) for i in input().split()) 

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

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

x = list()
x.append(x_first)

for i in range(0, 10):
    x_ans = r*x[i] - D
    x.append(x_ans)
    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 = 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):
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=x*r-d
    print(x)

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

XXX = [x]

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

for i in range(1, len(XXX)):
    print(XXX[i])

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

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

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

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

Solution (Python):
r, D, x2000 = map(int, input().split())
 
def rec(n):
    if n == 0:
        return x2000
    else:
        return r * rec(n-1) - D


for i in range(1, 11):
    print(rec(i))

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

Solution (Python):

"""
Created on Thu Jun  6 21:15:08 2019

@author: hisaki
"""

import numpy as np

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

def f(i):
    global x_2000
    global D
    global r
    if i == 2000:
        return x_2000
    temp = f(i-1)*r - D
    print (temp)
    return temp
  
    

f(2010)

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=map(int,input().split())
o=x
for i in range(1,11):
    n=r*o-d
    print(n)
    o=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())


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


n = [int(i) for i in input().split()]
for i in range(10):
    print(n[0]*n[2] - n[1])
    n[2] = n[0]*n[2] - n[1]

Solution (Python):
r,d,x = map(int,input().split())
if (2 <= r <= 5 and 1 <= d <= 100 and d < x <=200):
   for i in range(1,11):
       x = x * r
       x = x - d
       print(int(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_2000=map(int,input().split())
x=[x_2000]
for i in range(10):
  y=x[i]*r-D
  x.append(y)
  print(x[i+1])

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

Solution (Python):
r, D, *x = map(int, input().split())
for i in range(1,11):
    x.append(r*x[i-1]-D)
    print(x[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,x = map(int,input().split())
for i in range(1,11):
  print(int(D/(r-1)+(x-D/(r-1))*r**i))

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

if __name__ == '__main__':
    main()

Solution (Python):


if __name__ == '__main__':
    r, d, x = list(map(int, input().split()))
    ans = x
    for _ in range(10):
        ans = r * ans - d
        print(ans)

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

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

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

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

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):
r, D, x2000 = [int(x) for x in input().split()]
x = x2000

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

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

def f(r, D, x_2000):
    re = x_2000 * r - D
    return re

for i in range(10):
    ans = f(r, D, x_2000)
    x_2000 = ans
    print(ans)

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

Solution (Python):
r, d, x2000 = [int(v) for v in input().split()]
x = x2000
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(0,11):
    x.append(r * x[i] - D)
    if ( i != 0):
        print(x[i])

Solution (Python):
def p(a):
    print(a)

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

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

L = list(map(int,input().split()))
r = L[0]
D = L[1]
x = L[2]

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

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

for i in range(10):
	mo = r * molist[i] - d
	molist.append(mo)
del molist[0]
for mo in molist:
	print(mo)

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

def algae(r, d, weight):

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

def main():
    r,d,x = [int(i) for i in input().split()]
    algae(r,d,x)
    

if __name__ == "__main__":
    main()

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

Solution (Python):
def solve():
    multiConst, decreaseConst, x2000 = map(int, input().split())
    ans = x2000
    for i in range(10):
        ans = (multiConst * ans) - decreaseConst
        print(ans)
solve()

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

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

Solution (Python):
nums = [int(e) for e in input().split()]

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

ans = 0

ans = x * r - d
print(ans)

ans = ans * r - d
print(ans)
ans = ans * r - d
print(ans)
ans = ans * r - d
print(ans)
ans = ans * r - d
print(ans)
ans = ans * r - d
print(ans)
ans = ans * r - d
print(ans)
ans = ans * r - d
print(ans)
ans = ans * r - d
print(ans)
ans = ans * r - d
print(ans)

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):
a,b,c = map(int, raw_input().split())

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

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

ans = r*x_init - d
print(ans)
for i in range(1, 10):
    ans = r*ans - d
    print(ans)

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

def nextWeight(n):
    if n == 0:
        return x
    else:
        return r*nextWeight(n-1)-D

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

Solution (Python):
import numpy as np
r, D, x = (int(i) for i in input().split()) 
A = np.zeros(10)
for j in range(10):
  x = r*x-D
  print(x)

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

for i in range(2000,2010):
  xnex = r*x - D
  x = xnex
  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())
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 f(r, D, x):
    return r*x - D


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

for _ in range(10):
    x = f(r, D, x)
    print(x)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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=input().split()
m = int(x)
for i in range(1, 11):
    m = int(r) * int(m) - int(d)
    print(int(m))

Solution (Python):
import sys
inp = list(map(int,input().split()))
r, D, x = inp[0], inp[1], inp[2]

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

def j(q):
    if q==1: print("Yes")
    elif q == 0:print("No")
    exit(0)
rem = pow(10,9)+7
"""
def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")
"""

def ip():
    return int(input())
def printrow(a):
    for i in a:
        print(i)
def combinations(n,r):
    if n<r:return 0
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def permutations(n,r):
    if n<r:return 0
    return math.factorial(n) // math.factorial(n - r)
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)



r,x,y= (int(i) for i in input().split())       










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

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

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

Solution (Python):
r,d,x = map(int,input().split(' '))
i = 0
ans = ''
while i < 10:
    x = int(x*r - d)
    ans += str(x) + '\n'
    i += 1
print(ans[:-1])

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

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())
ans = []
ans.append(X2000)
for i in range(1,11):
    ans.append(ans[i - 1] * r - D)
    print(ans[i])

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

Solution (Python):
r, d, x = input().split()
intr, intd,intx = int(r), int(d), int(x)
mgrm = []
mgrm.append(intx)

for i in range(1, 11):
    mgrm.insert(i, intr * mgrm[i - 1] - intd)
    print(mgrm[i])

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

while ope_num > 0:
  X = (r * X) - D
  print(X)
  
  ope_num -= 1

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

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

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

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

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

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

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

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

Solution (Python):

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

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

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

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

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

Solution (Python):
r,D,X=map(int,input().split())
i=0
ans=r*X-D
print(ans)
while i<9:
    ans=ans*r-D
    print(ans)

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

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

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