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

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

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

Solution (Python):
import sys
range = xrange
input = raw_input

r,d,xend = [int(x) for x in input().split()]

X = [xend]
while len(X)<11:
    X.append(X[-1]*r - d)
print '\n'.join(str(x) for x in X[1:])

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

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

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

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

 
import math
import numpy as np
import random
import copy
import statistics 
import bisect
import heapq
from collections import defaultdict 

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

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

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

Solution (Python):
from sys import stdin
import math
import fractions
from collections import deque

INF = 10 ** 10

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

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

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

Solution (Python):


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

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

for _ in range(10):
    x = next(x)
    print(x)

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

Solution (Python):
from sys import exit

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

_x = x2000

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
n, m, k = input().split()
R = int(n)
D = int(m)
X = int(k)

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

Solution (Python):


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


def submit():
    r, d, x = read_input()

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

    return

if __name__ == '__main__':
    submit()

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

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

Solution (Python):

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys
rr = lambda: sys.stdin.readline().strip()
rri = lambda: int(rr())
rrs = lambda: [int(_) for _ in rr().split()]

r, D, x = rrs()

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(_) for _ in input().split()]
for iii 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):
a,b,c = map(int, input().split())
for i in range(10):
    c = c*a - b
    print(c)

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

Solution (Python):
r,D,x = map(int, input().split())
xs = [x]
for _ in range(10):
    xs.append(r*xs[-1 ]-D)
for xi in xs[1:]:
    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):
import sys

def main():
    input = sys.stdin.readline
    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):
p = input().split()
r,d,x = int(p[0]),int(p[1]),int(p[2])
for i in range(10):
    x = r*x-d
    print(x)

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

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

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

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

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

sys.setrecursionlimit(10 ** 7)

def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x) - 1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

r,d,x = li()

for _ 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 = 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())
ans = [0] * 10

ans[0] = R*X-D
print(ans[0])

for i in range(1,10):
    ans[i] = R*ans[i-1]-D
    print(ans[i])

Solution (Python):
import sys
import math
from itertools import permutations
input = sys.stdin.readline

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

arr=[x]

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

Solution (Python):

import sys
from collections.abc import Iterable
from math import *
from itertools import *
from collections import *
from functools import *
from operator import *
try:
    from math import gcd
except Exception:
    from fractions import gcd
readInt = lambda: int(sys.stdin.readline())
readIntN = lambda: [int(v) for v in sys.stdin.readline().split(' ')]



def main():
    
    r, D, x = readIntN()
    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):



r, d, x = map(int, input().rstrip().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(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):
import sys
input = sys.stdin.readline

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

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

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())
X = [x] + [0 for i in range(10)]
for i in range(1, 11):
        X[i] = X[i-1] * r - D
        print(X[i])

Solution (Python):

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

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

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

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

Solution (Python):
r, D, x = [int(c) for c 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):
def intinput():
    return map(int,input().split())

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

Solution (Python):

















import math
import copy
from collections import defaultdict
from collections import Counter
from collections import deque

from itertools import product

from itertools import permutations

from itertools import combinations
from bisect import bisect_left, bisect_right


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


dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]

def i_inpl(): return int(input())
def s_inpl(): return map(int,input().split())
def l_inpl(): return list(map(int, input().split()))
INF = float("inf")





r, D, x = l_inpl()

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 = 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)
    x=X

Solution (Python):
r, d, x = map(int, 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(2000, 2010):
    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):
read = input 
rn = lambda :map(int, read().split())
r, d, x = rn()
for i in range(10):
    x = r * x - d
    print(x)

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

x = [0] * 11
x[0] = x0

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

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

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

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

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

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

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

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

Solution (Python):
import sys

from fractions import gcd





from itertools import accumulate













input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())



if __name__ == '__main__':
    r, D, x = mi()
    for i in range(10):
        x = r * x - D
        print(x)

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

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

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

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

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys

mod = 10**9+7
sys.setrecursionlimit(mod) 


r,D,x = map(int,input().split())
ans = [0 for i in range(11)]
ans[0] = x
for i in range(10):
    ans[i+1] = r*ans[i]-D

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

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

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

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

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

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

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

solve()

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

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

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

Solution (Python):
import math
import functools
import itertools
import numpy as np
import sys
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

r,D,x = IL()

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

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

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

Solution (Python):


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

l=x2000
for i in range(10):
	n=r*l-D
	print(n)
	l=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=[int(x) for x in input().split()]
out=x
for i in range(1,11):
    out=out*r-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):
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)


main()

Solution (Python):

import sys


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


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    r = int(next(tokens))  
    d = int(next(tokens))  
    x = int(next(tokens))  
    solve(r, d, x)

if __name__ == '__main__':
    main()

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

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

xi = x2000

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

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

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

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

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

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

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

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

for i in range(2001, 2011):
    X = R * X - D
    print(X)

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

for i in range(1,11):
    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):
def getlist():
	return list(map(int, input().split()))

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

Solution (Python):

from math import *

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

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 bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)


def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


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


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(r, D, x2000):
    x = x2000
    for i in range(1, 10+1):
        x = r*x - D
        print(x)


def main():
    r, D, x2000 = read_int_n()
    (slv(r, D, x2000))


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):
a,b,c=map(int, input().split())
t=[c]
for i in range(10):
    t.append(a*t[-1]-b)
for i in t[1:]:print(i)

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

Solution (Python):





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


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

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

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

Solution (Python):
from itertools import product
import bisect
import sys


def input():
    return sys.stdin.readline()[:-1]









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

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

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

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

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

Solution (Python):


import sys                                                      
sys.setrecursionlimit(10**6)                                    
from collections import deque, Counter                          
from itertools   import accumulate, permutations, combinations  
from operator    import itemgetter                              
from bisect      import bisect_left, bisect_right, bisect       
from heapq       import heappop, heappush                       
from fractions   import gcd                                     
from math        import ceil, floor, sqrt, cos, sin, tan, pi    
from copy        import deepcopy                                
import numpy         as np                                      


def main():
    
    im = InputManager()
    
    r, d, x_2000 = im.inputMultiple()
    
    x_next = x_2000
    for _ in range(10):
        x_next = r * x_next - d
        print(x_next)
    

    
    return


class InputManager(object):
    def __init__(self):
        pass

    @staticmethod
    def inputSingle(dtype=int):
        return dtype(input())
    
    @staticmethod
    def inputMultiple(dtype=int, aslist=False):
        if aslist:
            return list(map(dtype, input().split()))
        else:
            return map(dtype, input().split())

    @staticmethod
    def input2D(h, dtype=int):
        return [list(map(dtype, input().split())) for i in range(h)]


main()

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

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

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

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

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

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

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

x1 = r*x0-D
l = [x1]
for i in range(10):
  print(l[i])
  l.append(l[i]*r-D)

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)

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

r,d,x = na()

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
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 II(): return int(sys.stdin.readline())
def SI(): return input()

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


main()

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

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

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

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

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

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
Max = sys.maxsize
def l():
	return list(map(int,input().split()))
def m():
	return map(int,input().split())
def s(x):
	a = []
	aa = x[0]
	su = 1
	for i in range(len(x)-1):
		if aa == x[i+1]:
			a.append([aa,su])
			aa = x[i+1]
			su = 1
		else:
			su += 1
	a.append([aa,su])
	return a
def jo(x):
	return " ".join(map(str,x))


r,d,x = m()

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

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

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

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

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

current = x2000
for i in range(2001, 2010 + 1):
    current = r * current - d
    print(current)

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

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

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

Solution (Python):
import collections as c
ip = lambda : map(int, input().split())


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

Solution (Python):
r, d, x = map(int, input().split())
def f(r, d, x):
    return r * x - d

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

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

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

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

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

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

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

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

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

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

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

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


import sys
import math

import array
import bisect
import collections
from collections import Counter, defaultdict
import fractions
import heapq
import re

sys.setrecursionlimit(1000000)


def array2d(dim1, dim2, init=None):
    return [[init for _ in range(dim2)] for _ in range(dim1)]

def argsort(l, reverse=False):
    return sorted(range(len(l)), key=lambda i: l[i], reverse=reverse)

def argmin(l):
    return l.index(min(l))

def YESNO(ans, yes="YES", no="NO"):
    print([no, yes][ans])

II = lambda: int(input())
MI = lambda: map(int, input().split())
MIL = lambda: list(MI())
MIS = lambda: input().split()


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


if __name__ == "__main__":
    main()

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

Solution (Python):
import sys
import collections
ns = lambda: sys.stdin.readline().rstrip()
ni = lambda: int(ns())
nm = lambda: map(int, sys.stdin.readline().split())
nl = lambda: list(nm())
nsm = lambda: map(str, sys.stdin.readline().split())

r, d, x = nm()

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

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

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

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