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

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

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

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

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

x_i = x_2000

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

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

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

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

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

r = parents[0]
D = parents[1]
start = parents[2]

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

Solution (Python):


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

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

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

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

Input = input().split()
r = int(Input[0])
D = int(Input[1])
x = int(Input[2])

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

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


main()

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

Solution (Python):



import sys

input = sys.stdin.readline

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

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())
ans = []
for _ in range(1, 11):
    tmp = r * x - d
    ans.append(tmp)
    x = tmp
for _ in ans:
    print(_)

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

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

Solution (Python):
import sys
sys.setrecursionlimit(1000000)
 
r,D,x = map(int,input().split())

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

Solution (Python):
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
else:
    _str = str
    str = lambda x=b"": x if type(x) is bytes else _str(x).encode()





inf = float("inf")
mod = 10**9+7







def dmain():
    sys.setrecursionlimit(100000000)
    threading.stack_size(40960000)
    thread = threading.Thread(target=main)
    thread.start()
    

abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod,MOD=1000000007,998244353
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def getKey(item): return item[0] 
def sort2(l):return sorted(l, key=getKey)
def d2(n,m,num):return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo (x): return (x and (not(x & (x - 1))) )
def decimalToBinary(n): return bin(n).replace("0b","")
def ntl(n):return [int(i) for i in str(n)]

def gcd(x, y):
    while y:
        x, y = y, x % y
    return x


def factorial_p(n, p):
    ans = 1
    if n <= p // 2:
        for i in range(1, n + 1):
            ans = (ans * i) % p
    else:
        for i in range(1, p - n):
            ans = (ans * i) % p
        ans = pow(ans, p - 2, p)
        if n % 2 == 0:
            ans = p - ans
    return ans

def nCr_p(n, r, p):
    ans = 1
    while (n != 0) or (r != 0):
        a, b = n % p, r % p
        if a < b:
            return 0
        ans = (ans * factorial_p(a, p) * pow(factorial_p(b, p), p - 2, p) * pow(factorial_p(a - b, p), p - 2, p)) % p
        n //= p
        r //= p
    return ans

def prime_sieve(n):
    """returns a sieve of primes >= 5 and < n"""
    flag = n % 6 == 2
    sieve = bytearray((n // 3 + flag >> 3) + 1)
    for i in range(1, int(n**0.5) // 3 + 1):
        if not (sieve[i >> 3] >> (i & 7)) & 1:
            k = (3 * i + 1) | 1
            for j in range(k * k // 3, n // 3 + flag, 2 * k):
                sieve[j >> 3] |= 1 << (j & 7)
            for j in range(k * (k - 2 * (i & 1) + 4) // 3, n // 3 + flag, 2 * k):
                sieve[j >> 3] |= 1 << (j & 7)
    return sieve

def prime_list(n):                            
    """returns a list of primes <= n"""
    res = []
    if n > 1:
        res.append(2)
    if n > 2:
        res.append(3)
    if n > 4:
        sieve = prime_sieve(n + 1)
        res.extend(3 * i + 1 | 1 for i in range(1, (n + 1) // 3 + (n % 6 == 1)) if not (sieve[i >> 3] >> (i & 7)) & 1)
    return res

def is_prime(n):
    """returns True if n is prime else False"""
    if n < 5 or n & 1 == 0 or n % 3 == 0:
        return 2 <= n <= 3
    s = ((n - 1) & (1 - n)).bit_length() - 1
    d = n >> s
    for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
        p = pow(a, d, n)
        if p == 1 or p == n - 1 or a % n == 0:
            continue
        for _ in range(s):
            p = (p * p) % n
            if p == n - 1:
                break
        else:
            return False
    return True


def all_factors(n):
    """returns a sorted list of all distinct factors of n"""
    small, large = [],[]
    for i in range(1, int(n**0.5) + 1, 2 if n & 1 else 1):
        if not n % i:
            small.append(i)
            large.append(n//i)
    large.reverse()
    small.extend(large)
    return small

def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()



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


BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        if self.buffer.tell():
            return self.buffer.read()
        return os.read(self._fd, os.fstat(self._fd).st_size)

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", b" "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", b"\n"))
    if kwargs.pop("flush", False):
        file.flush()


sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
input = lambda: sys.stdin.readline().rstrip(b"\r\n")





if __name__ == "__main__":
    main()

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

x_i = x

for i in range(10):
    x_i = r * x_i - 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, raw_input().split())

_x_i = x_2000

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

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

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

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(2,12):
    print(int((r**(i-1))*(x+D/(1-r))-D/(1-r)))

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

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

r, D, x = [int(i) for i in input().split()]
n=2000
while True:
    n += 1
    if n > 2010:
        break
    x=next(r, D, x)
    print(x)

Solution (Python):

import sys

import heapq
import re
import bisect
import random
import math
import itertools
from collections import defaultdict, deque
from copy import deepcopy
from decimal import *

readl= lambda: list(map(int, sys.stdin.readline().split()))
readt= lambda: tuple(map(int, sys.stdin.readline().split()))
read = lambda: sys.stdin.readline().rstrip()
readi = lambda: int(read())
readmi = lambda: map(int, sys.stdin.readline().split())
readms = lambda: map(str, sys.stdin.readline().split())

r, D, x = readmi()
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, x2000 = list(map(int,input().split()))

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

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

ans = x

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

Solution (Python):
r, D, x2000 = map(int, input().split())
xi = x2000
for i in range(0, 10):
    xi1 = r * xi - D
    print("{}".format(xi1))
    xi = xi1

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

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

Solution (Python):

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




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

xiplus1(r,d,x2000,2000)

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

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

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

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

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

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

for n in range(10):
    xn = r*xn - D
    print(xn)

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

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

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

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

x = x2000
for i in range(10):
    x = x * r - 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 = 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):
from sys import stdin
import numpy as np









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

def f(_x):
  return r*_x - D

for i in range(10):
  x = f(x)
  print(x)

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

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

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

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

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

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

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

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

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

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

def calc_weight(r, D, x):
    return r * x - D
  
x = x_2000
for i in range(10):
    x = calc_weight(r, D, x)
    print(x)

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

x = []
for i in range(10):
  if i == 0:
    x.append(a[0]*a[2]-a[1])
  else:
    x.append(a[0]*x[i-1]-a[1])
  print(x[i])

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

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

    print(x[i+1])

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

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

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

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

Solution (Python):
def i_input(): return int(input())
def s_input(): return map(int,input().split())
def l_input(): return list(map(int, input().split()))

r, D, x = l_input()

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

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

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

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

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

if __name__ == "__main__":
    main()

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

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

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

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

Solution (Python):
from collections import Counter
from collections import deque
from functools import reduce
from pprint import pprint

import bisect
import copy
import fractions
import math
import random
import sys
import time
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def MI(): return map(int, sys.stdin.readline().split())
def II(): return int(sys.stdin.readline())
def IS(): return input()
def C(x): return Counter(x)
def GCD_LIST(numbers):
    return reduce(fractions.gcd, numbers)
def LCM_LIST(numbers):
    return reduce(LCM, numbers)
def LCM(m, n):
    return (m * n // fractions.gcd(m, n))
def unite(x, y):
    
    x = root(x)
    y = root(y)
    if x == y:
        return
    
    node[x] = y
def same(x,y): return bool(root(x) == root(y))
def root(x):
    if node[x] == x:  
        return x
    else:
        node[x] = root(node[x])  
        return node[x]
def dfs(v):
    
    visited[v] = True
    for v2 in range(n):
        if graph[v][v2] == False:  
            continue
        if visited[v2] == True:  
            continue
        dfs(v2)

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

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

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

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

Solution (Python):
flag=False
cnt=0
r,D,x=map(int,input().split())
while cnt<10:
    tmp=x
    x=r*tmp-D
    print(x)
    cnt+=1

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

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

r = data[0]
d = data[1]
x = data[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):

x = [0] * 11

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

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

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

Solution (Python):
from sys import stdin

def main():
    r,d,x = [int(x) for x in stdin.readline().rstrip().split()]
    curr = x
    for _ in range(10):
        curr = r * curr - d
        print(curr)
    
if __name__=='__main__':
    main()

Solution (Python):


import math
import re

def main(params):
    r,d,x = params[0].split()
    r = int(r)
    d = int(d)
    x = int(x)
    base = 2000
    for i in range(1,11):
        newX = r * x - d
        print newX
        x = newX



if __name__ == "__main__":
    cnt = 1 
    params = []
    for i in range(cnt):
        param = raw_input()
        params.append(param)
    main(params)

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

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

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

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

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

Solution (Python):
import sys
import bisect
from collections import defaultdict

ans=0

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

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

Solution (Python):
from __future__ import print_function


import sys
import math
import string
import fractions
import re
import array
import copy
import functools
import operator

import collections
import itertools
import bisect
import heapq


from heapq import heappush
from heapq import heappop



import random




def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)


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

Solution (Python):
def main():
    """
    x(i+1)=r * x(i)−D
    2001
    2010
    """
    r, D, x2000 = map(int, input().split())

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


if __name__ == '__main__':
    main()

Solution (Python):

"""



"""
import sys


def solve(r, D, x):
    ans = []
    for i in range(10):
        x = r*x - D
        x = max(x, 0)
        ans.append(x)
    return ans


def main(args):
    r, D, x = map(int, input().split())
    ans = solve(r, D, x)
    print(*ans, sep='\n')


if __name__ == '__main__':
    main(sys.argv[1:])

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

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


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

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
import numpy as np
words = lambda t : list(map(t, input().split()))
r,d,x1 = words(int)

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

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

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

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

Solution (Python):
n,m,k=list(map(int,input().split()))
a=[k]
for i in range(10):
    s=n*a[-1]-m
    a.append(s)
    print(a[-1])

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

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

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

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

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

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

Solution (Python):

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

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




import itertools

def main():
    
    r, d, x2000 = [int(s) for s in input().split()]
    
    ans = list(range(11))
    ans[0] = x2000
    def func(xi, xj):
        return r*xi - d
    ans = list(itertools.accumulate(ans, func))
    
    for i in range(1, 11):
        print(ans[i])

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
from io import StringIO
from collections import *
from functools import *
import sys


def main(inputs):
    
    
    
    r, d, x = map(int, next(inputs).split())
    for i in range(10):
        x = r*x-d
        print(x)
        pass
    return


def gen_inputs(str_=None):
    inputs = StringIO(str_) if str_ else sys.stdin
    while True:
        a = inputs.readline().rstrip()
        yield a
        pass
    pass


if __name__ == "__main__":
    main(gen_inputs())
    pass

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


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

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

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

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

Solution (Python):
import sys

fin = sys.stdin.readline
r, D, x = [int(elem) for elem in fin().split()]

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

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

hoge = [x]

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

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

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

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

Solution (Python):





def main():
    

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

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


if __name__ == '__main__':
    main()

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

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

Solution (Python):

import time
import os
import time
import re
import math


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

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

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

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

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

def func(x):
    y = r * x - D
    return y

x = xo

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

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

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

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

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

Solution (Python):


import math

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

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

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

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

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

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

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

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
input = sys.stdin.readline
 


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

	ans = []
	for i in range(10):
		if i == 0:
			tmp = r * x2000 - D
			ans.append(tmp)
		else:
			tmp = r * ans[i-1] - D
			ans.append(tmp)
	
	for i in ans:
		print(i)


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(1, 11):
    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, x2000 = map(int, input().split(' '))

x = x2000
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 = 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, x0 = [int(i) for i in input().split(" ")]
x = [0] * 11
x[0] = x0

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