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 unittest


class TestB(unittest.TestCase):
    def test_1(self):
        self.assertEqual(
            think(2, 10, 20),
            [30, 50, 90, 170, 330, 650, 1290, 2570, 5130, 10250]
        )

    def test_2(self):
        self.assertEqual(
            think(4, 40, 60),
            [200, 760, 3000, 11960, 47800, 191160, 764600, 3058360, 12233400, 48933560]
        )


def solve():
    r, d, x = read()
    result = think(r, d, x)
    write(result)


def read():
    return read_int(3)


def read_int(n):
    return read_type(int, n)


def read_float(n):
    return read_type(float, n)


def read_type(t, n):
    return list(map(lambda x: t(x), read_line().split(' ')))[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(r, d, x):
    length = 10
    result = [x]
    for i in range(length):
        result.append(result[-1] * r - d)
    return result[1:]


def write(result):
    for r in result:
        print(r)


if __name__ == '__main__':
    
    solve()

Solution (Python):
l=list(map(int,input().split()))
r=l[0]
D=l[1]
x=l[2]
t=[x]
for i in t:
  m=i*r-D
  t.append(m)
  if(len(t)==11):
    break
for p in t[1:]:
	print(p)

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

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

W = X
for i in range(10):
  W = r*W-d
  print(W)
  X +=W

Solution (Python):



def ri():
    return int(input())

def rl():
    return list(input().split())

def rli():
    return list(map(int, input().split()))

def main():
    r, d, x = rli()
    nx = x
    for i in range(10):
        nx = r*nx-d
        print(nx)


if __name__ == '__main__':
    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,x2000=map(int,input().split())
S=[0]*20
S[0]=x2000
for i in range(1,11):
  S[i]=(S[i-1]*r-D)
  print(S[i])

Solution (Python):
def main():
    i = list(map(int, input().split()))

    if i[0] < 2 or 5 < i[0]:
        return
    if i[1] < 1 or 100 < i[1]:
        return
    if i[2] <= i[1] or i[1] > 200:
        return

    for j in range(10):
        a = i[0] * i[2] - i[1]
        print(a)
        i[2] = a 

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

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

a = [x]

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
import numpy as np
def print_ans(r, D, x):
    """Test Case
    >>> print_ans(2, 10, 20)
    30
    50
    90
    170
    330
    650
    1290
    2570
    5130
    10250
    >>> print_ans(4, 40, 60)
    200
    760
    3000
    11960
    47800
    191160
    764600
    3058360
    12233400
    48933560
    """
    for _ in range(10):
        x = r * x - D
        print(x)

if __name__ == '__main__':
    r, D, x = map(int, input().rstrip().split())
    print_ans(r, D, x)

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

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

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

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

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

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

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 = 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):
from collections import defaultdict,deque, Counter
import sys,heapq,bisect,math,itertools,string,queue,copy,time
import numpy as np
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
ans = 0


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

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

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

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

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

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

Solution (Python):

r, d, x2000 = [int(s) for s in input().split()]

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

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

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

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

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

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

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

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

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


def gcd(a, b):
    
    while b > 0:
        a, b = b, a % b

    return a


r, d, x = inpl()

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

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

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

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

pre = x

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

Solution (Python):
import sys
sys.setrecursionlimit(10**9)
INF=10**18
def input():
    return sys.stdin.readline().rstrip()

def main():
    r,D,x=map(int,input().split())
    l=[x]
    for i in range(10):
        l.append(l[i]*r-D)
    l=list(map(str,l))
    print(' '.join(l[1:]))

if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):

import sys










def main():
    r, d, x0 = [int(x) for x in sys.stdin.readline().split()]
    x = x0
    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 = 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_2000=map(int,input().split())

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

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

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

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

Solution (Python):
r,D,x = input().split()
r,D,x = int(r),int(D),int(x)
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):
tmp = list(map(int, input().split()))
r = tmp[0]
d = tmp[1]
x0 = tmp[2]

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

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

Solution (Python):

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

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

xi = x
ans = []
for i in range(2001,2011):
  xi = r * xi - D
  ans.append(xi)

for i in ans:
  print(i)

Solution (Python):
growth_rate, decayed_weight, initial_weight  = map(int, input().split(" "))

def calc(weight):
    return growth_rate * weight - decayed_weight

weight = initial_weight
for _ in range(10):
    weight = calc(weight)
    print(weight)

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
    r,d,x=map(int,input().split())
    A=[0]*11
    A[0]=x
    for i in range(10):
        A[i+1]=r*A[i]-d
    for i in range(1,11):
        print(A[i])
resolve()

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

dp = [0] * 11
dp[0] = x2000
for i in range(1, 11):
    dp[i] = r * dp[i - 1] - D
    print(dp[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,x0=map(int, input().split())

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

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

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

Solution (Python):
from collections import Counter,defaultdict,deque
import sys,bisect,math,itertools,string,queue
from heapq import heappop, heappush
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))

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

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

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

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

for j in range(0,10):
  print(li[j])

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

x = [x2000]

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

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

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

Solution (Python):
[r,d,x0]=map(int,raw_input().split())

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

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

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

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

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

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

Solution (Python):





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

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

if __name__ == '__main__':
    main()

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

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

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


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):

import sys


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

    return



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

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

x = x_0
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, x2000 = map(int, input().split())
x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
x[0] = x2000
for i in range(10):
  x[i + 1] = r * x[i] - D
  print(x[i + 1])

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

x = [0]*10
x[0] = r * x_ini - D
for i in range(9):
    x[i + 1] = r * x[i] - D

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

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

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

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

Solution (Python):

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

Solution (Python):


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

if __name__ == "__main__":
    main()

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

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

Solution (Python):
(sR, sD, sX) = input().split()
r = int(sR)
D = int(sD)
x = int(sX)
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())

list1 = [x]

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

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

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

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

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

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

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

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

Solution (Python):
r, D, x = map(int, input().split())
X = [x] * 11
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())

x = X
for i in range(1,11):
  y = r*x-D
  x = y
  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_base=list(int(el) for el in input().split(' '))
compute_next=lambda x: r*x-D

for i in range(10):
  x_base=compute_next(x_base)
  print(x_base)

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

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 _ 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):
AB = input().split()
r = int(AB[0])
D = int(AB[1])
init = int(AB[2])
a = r * init - D
print(a)
for i in range(9):
    a = (r * a) - D
    print(a)

Solution (Python):
from sys import stdin

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

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

Solution (Python):

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

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

for i in range(0,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())
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):
    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):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

for _ 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):
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 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):
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=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):
from sys import stdin
from itertools import combinations_with_replacement,product

a,b,c = [int(x) for x in stdin.readline().rstrip().split()]

x = c

for _ in range(2001,2011):
    x = a*x - b
    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())
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,x2000 = map(int,input().split())

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

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

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

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

Solution (Python):
data = [int(i) for i in input().split()]
ans = data[0]*data[2] - data[1]
print(ans)
for i in range(9):
    ans = data[0]*ans - data[1]
    print(ans)

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

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

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 = map(int,input().split())
dp = [0]*11
dp[0]=x
for i in range(10):
  dp[i+1] = r*dp[i] - D
  
print(*dp[1:], sep = "\n")

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,ini=map(int,input().split())
v=0
while v!=10:
  ini=ini*r-d
  v+=1
  print(ini)

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

Solution (Python):
import sys

input = sys.stdin.readline


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


if __name__ == "__main__":
    main()

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

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    r, d, x = list(map(int, input().rstrip('\n').split()))
    for i in range(10):
        x = r * x - d
        print(x)


if __name__ == '__main__':
    slove()

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

Solution (Python):
import sys
from bisect import *
from collections import *
from copy import deepcopy
from heapq import *
from itertools import *
from math import *
from operator import *
from pprint import *

sys.setrecursionlimit(10**8)

input = sys.stdin.readline

def main():
    """ main """
    r,D,x = map(int, input().split())
    res = [0]*11
    res[0] = x
    for i in range(1,11):
        res[i] = res[i-1]*r-D
        print(res[i])


if __name__ == '__main__':
    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,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 = r * x - d
print(ans)
for _ in range(9):
    ans = r * ans - d
    print(ans)

Solution (Python):
import sys
from io import StringIO
import unittest

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """2 10 20"""
        output = """30
50
90
170
330
650
1290
2570
5130
10250"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """4 40 60"""
        output = """200
760
3000
11960
47800
191160
764600
3058360
12233400
48933560"""
        self.assertIO(input, output)

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

if __name__ == "__main__":
    resolve()

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

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

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

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

Solution (Python):


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

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

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

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

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

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


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

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 = 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 _ in range(10):
    x.append(r * x[-1] - d)

for v in x[1:]:
    print(v)

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

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

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

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

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

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

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

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

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


if __name__ == '__main__':
    main()

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

r = li[0]
D = li[1]
x_2000 = li[2]

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

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