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

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

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

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

before = init
for year in range(10):
    before = int(r*before-D)
    print(before)

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

Solution (Python):
list=input().split(" ")
r=int(list[0])
d=int(list[1])
x=int(list[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):
from sys import stdin
data = stdin.readline().split()
r,D,x = int(data[0]), int(data[1]), int(data[2])
for itr in range(10):
    x = r * x - D
    print(x)

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

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

input=sys.stdin.readline
r,D,x2000 = map(int,input().split())
x = r*x2000-D
print(x)
for i in range(9):
  x = r*x-D
  print(x)

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

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

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

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

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

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 i 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
    if x < 0:
        x = 0
    print(x)

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

xi = []

for i in range(10):
    x = r*x -d
    xi.append(x)

for x in xi:
    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):
a, b, c = map(int,input().split())

x = c

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

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

Solution (Python):

"""
Created on Sat Apr 20 20:47:47 2019

@author: Owner
"""


"""
Created on Sat Apr 13 09:53:12 2019

@author: Owner
"""
import numpy as np
import sys
import collections
import scipy.misc
import math
from operator import itemgetter
import itertools
import copy
import bisect


def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(int(i))
    i += 1
  if n > 1:
    table.append(int(n))
  return table   

def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []
    
def getNearestValueIndex(list, num):
    """
    概要: リストからある値に最も近い値のインデックスを取得する関数
    @param list: データ配列
    @param num: 対象値
    @return 対象値に最も近い値
    """

    
    idx = np.abs(np.asarray(list) - num).argmin()
    return idx

def find_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default

class UnionFind(object):
    def __init__(self, n=1):
        self.par = [i for i in range(n)]
        self.rank = [0 for _ in range(n)]
        self.size = [1 for _ in range(n)]

    def find(self, x):
        """
        x が属するグループを探索
        """
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    def union(self, x, y):
        """
        x と y のグループを結合
        """
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                x, y = y, x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1
            self.par[y] = x
            self.size[x] += self.size[y]

    def is_same(self, x, y):
        """
        x と y が同じグループか否か
        """
        return self.find(x) == self.find(y)

    def get_size(self, x):
        """
        x が属するグループの要素数
        """
        x = self.find(x)
        return self.size[x]
    

"""
N, X = map(int, input().split())

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

P = [0]*N
Y = [0]*N
for n in range(N):
    P[n], Y[n] = map(int, input().split())


dp = np.zeros((N+1, 4,4,4))
    
all(nstr.count(c) for c in '753')


ABT = zip(A, B, totAB)
result = 0

sorted(ABT,key=itemgetter(2))
A, B, totAB = zip(*ABT)
A.sort(reverse=True)


(x >> i) & 1


dp = [np.inf]*N
for n in range(N):
    if n == 0:
        dp[n] = 0
    else:
        for k in range(1,K+1):
            if n-k >= 0:
                dp[n] = min(dp[n], dp[n-k] + abs(h[n]-h[n-k]))
            else:
                break

add = 1 
res = 0
sums = [0]*(len(nums)+1)
for i in range(len(nums)):
    sums[i+1] = sums[i] + nums[i]
for i in range(0, len(nums), 2):
    left = i
    right = min(i+add, len(nums))
    tmp = sums[right] - sums[left]
    res = max(tmp, res)


li, ri = bisect.bisect_left(p_ac, l[i]-1), bisect.bisect_right(p_ac, r[i]-1)    


org_list = [3, 1, 4, 5, 2]
new_list = sorted(org_list)
print(org_list)
print(new_list)




    for h in range(0,H):
        for w in range(0,W):
            if h == 0 and w == 0:
                pass
            elif h == 0:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h-1][W-w]+1)
            elif w == 0:   
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1)
            else:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1, D[H-h-1][W-w]+1, D[H-h][W-w]+2)
            d_max = max(D[H-h-1][W-w-1], d_max)

"""


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

    
if __name__ == '__main__':
    main()

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

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

Solution (Python):
import sys,heapq
from collections import deque,defaultdict
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
DBG = True 
def ddprint(x):
  if DBG:
    print(x)

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

Solution (Python):




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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import sys
input = sys.stdin.readline

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys,collections,math,random;sys.setrecursionlimit(10**7)
def Is(): return [int(x) for x in sys.stdin.readline().split()]
def Ss(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

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

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

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

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

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

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

Solution (Python):

"""
Created on Sat May 25 20:54:40 2019

@author: USER
"""

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

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


def next(x_n):
    return r*x_n -D


for i in range(10):
    x_n = next(x_n)
    print(x_n)

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

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

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

for i in range(10):
    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):


''' 
------------------------
author : iiou16
------------------------
'''

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

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

if __name__ == '__main__':
    main()

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

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

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


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


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

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

xi = x2000


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

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

Solution (Python):





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

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

if __name__ == '__main__':
    main()

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

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

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

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

"""<https://github.com/cheran-senthil/PyRival>"""
from __future__ import division, print_function

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


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

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




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


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

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

x_2001 = r * x_2000 - D
x_2002 = r * x_2001 - D
x_2003 = r * x_2002 - D
x_2004 = r * x_2003 - D
x_2005 = r * x_2004 - D
x_2006 = r * x_2005 - D
x_2007 = r * x_2006 - D
x_2008 = r * x_2007 - D
x_2009 = r * x_2008 - D
x_2010 = r * x_2009 - D

print(x_2001)
print(x_2002)
print(x_2003)
print(x_2004)
print(x_2005)
print(x_2006)
print(x_2007)
print(x_2008)
print(x_2009)
print(x_2010)

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

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

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

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

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

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

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

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


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

Solution (Python):
import math

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

Solution (Python):

"""
Created on Sat May 25 20:54:15 2019

@author: Yamazaki Kenichi
"""

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

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

for i in range(10):
    x = a(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())

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(1, 10+1):
    x = r * x - d
    print(x)

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


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

Solution (Python):




r, D, x_past = (int(i) for i in input().split())  

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

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

Solution (Python):

def solve(): 
    r, D, x =  map(int, input().split())
    res_l = []
    for _ in range(10):
        x = r*x - D
        res_l.append(str(x))
    
    return '\n'.join(res_l)

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

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

Solution (Python):
inpl = lambda: list(map(int,input().split()))
r, D, x = inpl()
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):
r,D,twokx = map(int,input().split())
x=twokx

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

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

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

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

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

num = X

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

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

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

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

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

for i in range(10):
    x = f(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, raw_input().strip().split())

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

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

Solution (Python):
import sys

readline = sys.stdin.readline

r, D, x2000 = map(int, readline().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):
def solve():
    r, D, x2000 = [int(_) for _ in raw_input().split()]
    ret = x2000
    for i in range(10):
        ret = r * ret - D
        print ret

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

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

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

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

res.sort()
for x in res:
    print(x)

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

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

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

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

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

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

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

Solution (Python):

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

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

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

Solution (Python):
import math
from functools import reduce
from collections import deque

def s(generator, splitter, mapper):
    return [ mapper(s) for s in generator().split(splitter) ]


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


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

r,d,x_2000 = get_nums_l()

now = x_2000
for i in range(10):
    new_a = now * r - d
    print(new_a)
    now = new_a

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

x = xt
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):









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

Solution (Python):
import math
import sys
sys.setrecursionlimit(10 ** 6 + 10)
from collections import defaultdict

def kari():
    map(int, input().split())

    num, num2 = map(int, input().split())
    data = [list(map(int, input().split())) for i in range(num2)]

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

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

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

print(B if A >= 13 else 0 if A <= 5 else int(B/2))
"""
r,D,x2000=map(int, input().split())
xNext=x2000*r-D
for i in range(10):
  print(xNext)
  xNext=xNext*r-D

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

Solution (Python):




r, D, x2000 = [int(x) for x in input().split()]

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

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

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


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

Solution (Python):
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline



def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [r, D, x] = [long(input_raw[0]), long(input_raw[1]), long(input_raw[2])]
    for i in range(10):
        x = r*x - D

        print x

if __name__ == '__main__':
    main()

Solution (Python):
import sys
input = sys.stdin.readline
r,d,x = input().split()
r = int(r)
d = int(d)
x = 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(1,11):
    print(r*x-D)
    x=r*x-D

Solution (Python):

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

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

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

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

r,D,x=MAP()

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

Solution (Python):
import sys
stdin = sys.stdin
 
sys.setrecursionlimit(10**5) 
 
def ii(): return int(stdin.readline())
def li(): return map(int, stdin.readline().split())

r, d, x = tuple(li())

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

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

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

if __name__ == '__main__':
    main()

Solution (Python):
r, D, x = map(int, input().split())
x_i = r * x - D
print(x_i)
for i in range(9):
    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):
if __name__ == '__main__':
    [r, d, x] = list(map(int, input().split()))
    for _ in range(10):
        x = r * x - d
        print(x)

Solution (Python):
R, D, X = map(int, raw_input().split())

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

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

Solution (Python):
import sys

r, d, x0 = list(map(int, sys.stdin.readline().strip().split(" ")))
tmp = x0

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

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