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):
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b



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


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


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

Solution (Python):



 
import sys
import math



 

fileoperation=0
if(fileoperation):
    orig_stdout = sys.stdout
    orig_stdin = sys.stdin
    inputfile = open('W:/Competitive Programming/input.txt', 'r')
    outputfile = open('W:/Competitive Programming/output.txt', 'w')
    sys.stdin = inputfile
    sys.stdout = outputfile


mod=1000000007
 

def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 
 

t=1
for tt in range(t):
    
    r,d,x= map(int, sys.stdin.readline().split(' '))
    for i in range(10):
        x=r*x - d
        print(x)
    
    
    

if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

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

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

Solution (Python):

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

ans=[x]

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

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

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

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

Solution (Python):
import sys


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

def main():
    r, D, x = i2nn()
    for _ in range(10):
        x = (r * x) - D
        print(x)

main()

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

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

Solution (Python):
r,d,x=map(int,input().split())
for i in range(10):
    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())
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):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import random

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 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 I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)


def main():
    a,b,c = LI()
    r = [c]
    for i in range(10):
        r.append(a*r[-1]-b)

    return '\n'.join(map(str, r[1:]))


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

import sys
INF = float("inf")


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


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

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):
def inpl(): return map(int, input().split())

r, D, X = inpl()
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):

def main():
    buf = input()
    buflist = buf.split()
    r = int(buflist[0])
    D = int(buflist[1])
    x2000 = int(buflist[2])
    x = x2000
    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 = [int(_) for _ in input().split()]

result = x

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

Solution (Python):
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())
X=[x]
for i in range(10):
    X.append(r*X[-1]-D)
    print(X[-1])

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

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

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

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

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

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

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

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

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

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

Solution (Python):
def main():
    from sys import stdin, stdout

    def read():
        return stdin.readline().rstrip('\n')

    def read_array(sep=None, maxsplit=-1):
        return read().split(sep, maxsplit)

    def read_int():
        return int(read())

    def read_int_array(sep=None, maxsplit=-1):
        return [int(a) for a in read_array(sep, maxsplit)]

    def write(*args, **kwargs):
        sep = kwargs.get('sep', ' ')
        end = kwargs.get('end', '\n')
        stdout.write(sep.join(str(a) for a in args) + end)

    def write_array(array, **kwargs):
        sep = kwargs.get('sep', ' ')
        end = kwargs.get('end', '\n')
        stdout.write(sep.join(str(a) for a in array) + end)

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

main()

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

Solution (Python):
import sys

sys.setrecursionlimit(10**7)

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

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

Solution (Python):
import sys
input = sys.stdin.readline
inf = float('inf')
mod = 10**9+7


def INT_(n): return int(n)-1


def MI(): return map(int, input().split())


def MF(): return map(float, input().split())


def MI_(): return map(INT_, input().split())


def LI(): return list(MI())


def LI_(): return [int(x) - 1 for x in input().split()]


def LF(): return list(MF())


def LIN(n: int): return [input() for _ in range(n)]


def LLIN(n: int): return [LI() for _ in range(n)]


def LLIN_(n: int): return [LI_() for _ in range(n)]


def LLI(): return [list(map(int, l.split())) for l in input()]


def I(): return int(input())


def F(): return float(input())


def ST(): return input().replace('\n', '')


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


import itertools
from collections import Counter
from collections import defaultdict
import bisect

def main():
    r, D, X = map(int, input().split())
    xi = X
    for i in range(1, 11):
        xi = r * xi - D
        print(xi)

if __name__ == '__main__':
    main()

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

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

Solution (Python):






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


from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy
from collections import defaultdict


mod = 1


def intin():
    input_tuple = input().split()
    if len(input_tuple) <= 1:
        return int(input_tuple[0])
    return tuple(map(int, input_tuple))


def intina():
    return [int(i) for i in input().split()]


def intinl(count):
    return [intin() for _ in range(count)]


def modadd(x, y):
    global mod
    return (x + y) % mod


def modmlt(x, y):
    global mod
    return (x * y) % mod


def lcm(x, y):
    while y != 0:
        z = x % y
        x = y
        y = z
    return x


def combination(x, y):
    assert(x >= y)

    if y > x // 2:
        y = x - y

    ret = 1

    for i in range(0, y):
        j = x - i
        i = i + 1

        ret = ret * j
        ret = ret // i

    return ret


def get_divisors(x):
    retlist = []
    for i in range(1, int(x**0.5) + 3):
        if x % i == 0:
            retlist.append(i)
            retlist.append(x // i)
    return retlist


def get_factors(x):
    retlist = []
    for i in range(2, int(x**0.5) + 3):
        while x % i == 0:
            retlist.append(i)
            x = x // i
    retlist.append(x)
    return retlist


def make_linklist(xylist):
    linklist = {}
    for a, b in xylist:
        linklist.setdefault(a, [])
        linklist.setdefault(b, [])
        linklist[a].append(b)
        linklist[b].append(a)
    return linklist


def calc_longest_distance(linklist, v=1):
    distance_list = {}
    distance_count = 0
    distance = 0
    vlist_previous = []
    vlist = [v]
    nodecount = len(linklist)

    while distance_count < nodecount:
        vlist_next = []
        for v in vlist:
            distance_list[v] = distance
            distance_count += 1
            vlist_next.extend(linklist[v])
        distance += 1
        vlist_to_del = vlist_previous
        vlist_previous = vlist
        vlist = list(set(vlist_next) - set(vlist_to_del))

    max_distance = -1
    max_v = None
    for v, distance in distance_list.items():
        if distance > max_distance:
            max_distance = distance
            max_v = v

    return (max_distance, max_v)


def calc_tree_diameter(linklist, v=1):
    _, u = calc_longest_distance(linklist, v)
    distance, _ = calc_longest_distance(linklist, u)
    return distance


class UnionFind:

    def __init__(self, n):
        self.parent = [i for i in range(n)]

    def root(self, i):
        if self.parent[i] == i:
            return i
        self.parent[i] = self.root(self.parent[i])
        return self.parent[i]

    def unite(self, i, j):
        rooti = self.root(i)
        rootj = self.root(j)
        if rooti == rootj:
            return
        if rooti < rootj:
            self.parent[rootj] = rooti
        else:
            self.parent[rooti] = rootj

    def same(self, i, j):
        return self.root(i) == self.root(j)





def main():
    r, d, x = intin()

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


if __name__ == '__main__':
    main()

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

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

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

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

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

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


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


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, x2000 = (int(_) for _ in input().split())
curr = x2000
for i in range(10):
    curr = r*curr - d
    print(curr)

Solution (Python):

import re
import bisect
from datetime import datetime as dt
r, D, X = map(int, input().split())
for i in range(10):
    X = r*X - D
    print(X)

Solution (Python):
import sys
from collections import deque
import math
sys.setrecursionlimit(20000000)

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

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

from __future__ import division, print_function

import os
import sys
from __builtin__ import xrange as range
from cStringIO import StringIO
from future_builtins import ascii, filter, hex, map, oct, zip
from io import IOBase

import __pypy__


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




BUFSIZE = 8192


class FastI(IOBase):
    def __init__(self, file):
        self._fd = file.fileno()
        self._buffer = StringIO()
        self.newlines = 0

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


class FastO(IOBase):
    def __init__(self, file):
        self._fd = file.fileno()
        self._buffer = __pypy__.builders.StringBuilder()
        self.write = lambda s: self._buffer.append(s)

    def flush(self):
        os.write(self._fd, self._buffer.build())
        self._buffer = __pypy__.builders.StringBuilder()


def print(*args, **kwargs):
    sep, file = kwargs.pop("sep", " "), 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", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


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



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):
from collections import defaultdict


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


if __name__ == '__main__':
    Solution().main()

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

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

Solution (Python):

def main():
    r, d, x = map(int, raw_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(1, 11):
    x = r * x - D
    print(x)

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

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

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

Solution (Python):
import sys, math, collections, heapq, itertools
F = sys.stdin
def single_input(): return F.readline().strip("\n")
def line_input(): return F.readline().strip("\n").split()
def gcd(a, b):
    a, b = max(a, b), min(a, b)
    while a % b > 0: a, b = b, a % b
    return b
  
def solve():
    r, d, x = map(int, line_input())
    ans = x
    for i in range(10):
        ans = r * ans - d
        print(ans)
    return 0
  
if __name__ == "__main__":
    solve()

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

Solution (Python):
ri = lambda: int(input())
rl = lambda: list(map(int,input().split()))
rr = lambda N: [ri() for _ in range(N)]
YN = lambda b: print('YES') if b else print('NO')
yn = lambda b: print('Yes') if b else print('No')
OE = lambda x: print('Odd') if x%2 else print('Even')
INF = 10**18
MOD=10**9+7

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

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def A():
    return


def B():
    r, d, x = LI()
    for i in range(10):
        print(x * r - d)
        x = x * r - d
    return


def C():
    return


def D():
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == '__main__':
    B()

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):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log2
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

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

Solution (Python):

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

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

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

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

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

Solution (Python):

def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(input())
def S(): return list(input())
r,d,x=IL()
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):


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

if __name__ == "__main__":
    solve()

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

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

Solution (Python):



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

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


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):
from collections import deque
from heapq import heappush,heappop
import re

def int_raw():
    return int(input())

def ss_raw():
    return input().split()

def ints_raw():
    return list(map(int, ss_raw()))

INF = 1<<29


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

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

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

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

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

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

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

r, D, x = map(int, input().split())
Box = []
Box.append(x)

for _ in range(10):
    Box.append(r * Box[-1] - D)
    print(Box[-1])

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

Solution (Python):
from collections import Counter, deque
from fractions import gcd
from functools import lru_cache
from functools import reduce
import functools
import heapq
import itertools
import math
import numpy as np
import re
import sys

sys.setrecursionlimit(10000)
INF = float('inf')


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)

Solution (Python):
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

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

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

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

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

Solution (Python):
import sys
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def II(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def SI(): return input()
YN = lambda b: print('YES') if b else print('NO')
yn = lambda b: print('Yes') if b else print('No')

r, D, x = LI()

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

Solution (Python):
import sys


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


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

Solution (Python):
from collections import defaultdict as ddic, deque, Counter
from itertools import permutations, combinations, product
import bisect, heapq

rr = raw_input
rri = lambda: int(raw_input())
rrm = lambda: map(int, raw_input().split())

def solve(r, D, x):
    ans = []
    for i in xrange(10):
        x = r * x - D
        ans.append(x)
    return ans
ans = solve(*rrm()) 
print "\n".join(map(str, ans))

Solution (Python):
r, d ,x = map(int, input().split())
array = []
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):
def getN():
    return int(input())

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

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

r, d, x = getlist()
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=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):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpl_str(): return list(input().split())

r,D,x = inpl()

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

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

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

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

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

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

Solution (Python):

if __name__ == '__main__':
    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,xt = map(int,input().split())

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

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

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

Solution (Python):



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

if __name__=="__main__":
    solve()

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

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

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