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

Solution (Python):


import sys

r, D, x = map(int, sys.stdin.readline().split(" ", 3))

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

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


def calcWeight(r, D, X, stepper):
    if stepper == 10:
        return X
    weight = r*X-D
    stepper += 1
    print(weight)
    return calcWeight(r, D, weight, stepper)


calcWeight(r, D, X, 0)

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

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

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

Solution (Python):

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

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

for i in range(10):
    print(s[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):
R, D, X2000 = map(int, input().split(" "))

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

Solution (Python):
a,b, c = map(int, input().split())
now = 0
for num in range(10):
    if num == 0:
        now = a * c -b
    else:
        now = a * now -b
    print(now)

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

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

Solution (Python):
r,D,x2000=map(int,input().split())
x2001=r*x2000-D
x2002=r*x2001-D
x2003=r*x2002-D
x2004=r*x2003-D
x2005=r*x2004-D
x2006=r*x2005-D
x2007=r*x2006-D
x2008=r*x2007-D
x2009=r*x2008-D
x2010=r*x2009-D
print(x2001)
print(x2002)
print(x2003)
print(x2004)
print(x2005)
print(x2006)
print(x2007)
print(x2008)
print(x2009)
print(x2010)

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

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

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

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

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


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

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

Solution (Python):
import sys
a, b, c = map(int, raw_input().split())
i=0
while 1:
  c = a*c - b
  print c
  i = i + 1
  if i > 9 :
      sys.exit()

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

def calu_weight(r, d, x):
    return r*x-d

w_l = []

for i in range(0,10):
    if i == 0:
        
        w_l.append(calu_weight(r,d,x))
        print(calu_weight(r,d,x))
    else:
        w_l.append(calu_weight(r,d,w_l[i-1]))
        print(calu_weight(r,d,w_l[i-1]))

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

x = x2000
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(str(x))

Solution (Python):
import sys

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

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

algae(r, D, x0)

Solution (Python):
x={}
i=list(map(int,input().split()))
for s in range(10):
  x[s]=int((i[2]-(i[1]/(i[0]-1)))*i[0]**(s+1)+(i[1]/(i[0]-1)))
  print(x[s])

Solution (Python):
r,D,x=[int(i) for i in input().split()]
for i in range(10):
    x = int((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):
from sys import stdin

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

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

Solution (Python):

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

for i in range(10):
    x = r * x - d
    print(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,zero=list(map(int,input().split()))
one=r*zero-D
two=r*one-D
three=r*two-D
four=r*three-D
five=r*four-D
six=r*five-D
seven=r*six-D
eight=r*seven-D
nine=r*eight-D
ten=r*nine-D
print(one)
print(two)
print(three)
print(four)
print(five)
print(six)
print(seven)
print(eight)
print(nine)
print(ten)

Solution (Python):
i=list(map(int,input().split()))
n=0
a=i[2]
while True:
  a=a*i[0]-i[1]
  print(a)
  n=n+1
  if n==10: 
    break

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


a=r*x-d
b=r*a-d
c=r*(b-a)+b
d=r*(c-b)+c
f=r*(d-c)+d
g=r*(f-d)+f
h=r*(g-f)+g
i=r*(h-g)+h
j=r*(i-h)+i
k=r*(j-i)+j

v=[a,b,c,d,f,g,h,i,j,k]
for i in v:
    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 = map(int, input().split())



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

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

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

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

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

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

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

    x_last = x2000

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

    return


if __name__ == '__main__':
    calc()

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

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

Solution (Python):
def calc1():
  A=list(map(int,input().split()))
  r=A[0]
  D=A[1]
  x=A[2]
  B=[]
  g=(r*x)-D
  B.append(g)
  for z in range(1,10):
    C=B[z-1]
    g=(r*C)-D
    B.append(g)
  
  for x in range(len(B)):
    print(B[x])
    
if __name__=="__main__":
  calc1()

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

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

Solution (Python):
r, D, x2000 = map(int, input().split())
xi = x2000
ans = 0
for i in range(2001, 2011):
    ans = r * xi - D
    print('{}'.format(ans))
    xi = ans

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

Solution (Python):

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

x = []


def dfx(r, D, xLast):
    ans = xLast * r - D
    x.append(ans)
    if (len(x)) < 10:
        dfx(r, D, ans)
    else:
        for i in range(len(x)):
            print(x[i])


x = dfx(r, D, x2000)

Solution (Python):
import collections
import math 
N,A,B = map(int, input().split())
s = B
for i in range(10):
    s = s*N-A
    print(s)

Solution (Python):

def main():
    r,D,x = map(int,input().split())
    xs = list()
    xs.append(x)
    for i in range(10):
        xst = r*xs[i]-D
        xs.append(xst)
        if i != 0:
            print(xs[i])
    print(xs[10])
if __name__ == '__main__':
    main()

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

Solution (Python):
tmp = input()
nu = tmp.find(' ')
nunu = tmp.rfind(' ')

r = int(tmp[:nu:])
D = int(tmp[nu+1:nunu:])
Xtwo = int(tmp[nunu+1::])

if(r >=2 and r <= 5 and D >= 1 and D <= 100 and Xtwo >= D and Xtwo <= 200):
  xone = r * (Xtwo) - D
  for i in range(10):
    print(xone)
    xone = r * (xone) - D

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

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

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

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

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

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

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

Solution (Python):

import sys

s = (input().split(' '))

r,d,x = [int(i) for i in s]

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

Solution (Python):



INT = list(map(int,input().split()))
r,D,X = INT[0],INT[1],INT[2]



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

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

tmp = r * x2000 - d
print(tmp)
for i in range(9):
    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 = 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()]
y = []
y.append(x)
tmp = 0
tmp2 = 0
for i in range(10):
    tmp = y.pop(0)
    tmp2 = tmp*r-D
    print(tmp2)
    y.append(tmp2)

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

Solution (Python):
a, b, c = input().split()
a, b, c = int(a), int(b), int(c)

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):
num = input().split()

r = int(num[0])
D = int(num[1])
x = int(num[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):
import queue

"""
N = int(input())



A = []
for i in range(N):
	A.append(int(input()))

print(A)

"""
(N,M,R) = (int(i) for i in input().split(" "))
for i in range(10):
	R = N*R-M
	print(R)

Solution (Python):

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

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

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

def next_year(year):
  return R * year - D

ans = X
for i in range(0, 10):
  ans = next_year(ans)
  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 sys
input = sys.stdin.readline

def io_generator():
	return input()

def iil(a_io):
	return map(int, a_io().split())





def main(io):
	a,b,x=iil(io)
	
	for i in range(10):
		x=a*x-b
		print(x)
	
	return



if __name__ == "__main__":
	io= lambda : io_generator()
	ret = main(io)
	if ret is not None:
		print(ret)

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

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

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

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

Solution (Python):
import sys

input = sys.stdin.readline
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 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(n) for n in input().split())

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

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

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


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

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

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

Solution (Python):
r, D, x2000 = map(int, input().split())
xi = 0
ans = 0
for i in range(2001, 2011):
    if i == 2001: xi = x2000
    ans = r * xi - D
    print(ans)
    xi = ans

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

r=l[0]
d=l[1]
x=l[2] 
for i in range(0,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] = [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):
tmp = input()
r, D, x2000 = tmp.split()
r, D, x2000 = int(r),int(D),int(x2000)

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

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

Solution (Python):

import sys



def solve(lines):
    r,D,X = map(int, lines.pop(0).split(' '))
    for i in range(10):
        X = r * X - D
        print(X)
lines = [x.strip() for x in sys.stdin.readlines()]




solve(lines)

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

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

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

new_x = r * x - d
print(new_x) 
for i in range(2002, 2011):
    new_x = r * new_x - d
    print(new_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())

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

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

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

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

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

Solution (Python):


import sys

debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        lines.append(input())

    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    token = lines[0].split()
    r = int(token[0])
    d = int(token[1])
    x = int(token[2])

    return (r, d, x)


def solve(r, d, x):

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

    return result


def main():
    



    solve(*parse_input())

if __name__ == '__main__':

    main()

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

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

    print(x)

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


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

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

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

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

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






ans = list()
ans.append(x_2000)
for i in range(1,11):
    ans.append(r*ans[i-1] - D)

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

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())
ans = [x]

for i in range(11):
    ans.append((r * ans[i]) - d)
    if i == 0:
        continue
    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):
read=input
r,d,x=map(int,read().split(' '))
for i in range(10):
  x=int(r*x-d)
  print(x)

Solution (Python):
r, d, x2000 = map(int,input().split())
for var in range(0, 10):
  xi = (r * x2000) - d
  print(xi)
  x2000 = xi

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

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

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

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 = [int(s) for s in input().split(' ')]
ans = []
ans.append(r*x-d)

for i in range(1,10):
    ans.append(r * ans[i-1] - d)
    
for j in ans:
    print(j)

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

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

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

Solution (Python):
r,d,x=map(int,input().split())
z_1=r*x-d
z_2=r*z_1-d
z_3=r*z_2-d
z_4=r*z_3-d
z_5=r*z_4-d
z_6=r*z_5-d
z_7=r*z_6-d
z_8=r*z_7-d
z_9=r*z_8-d
z_10=r*z_9-d
print(z_1)
print(z_2)
print(z_3)
print(z_4)
print(z_5)
print(z_6)
print(z_7)
print(z_8)
print(z_9)
print(z_10)

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

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

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

Solution (Python):
r,d,x=map(int,input().split())
num1=r*x-d
num2=num1*r-d
num3=num2*r-d
num4=num3*r-d
num5=num4*r-d
num6=num5*r-d
num7=num6*r-d
num8=num7*r-d
num9=num8*r-d
num10=num9*r-d
print(num1)
print(num2)
print(num3)
print(num4)
print(num5)
print(num6)
print(num7)
print(num8)
print(num9)
print(num10)

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

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())
i=0
while (i<=9):
    X=r*X-D
    print(X)
    i+=1

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

i = 0
while i < 10:
  x = r * x - D
  print(x)
  i += 1

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

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

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

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

x_back = x2000


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

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

for i in range(10):
    print(int(r ** (i + 1) * (X2000 - D / (r - 1)) + D / (r - 1)))

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

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

Solution (Python):
A,B,C=list(map(int,input().split()))
ans=C
for _ in range(10):
    ans=A*ans-B
    print(ans)

Solution (Python):
input = input().split()

intList = [int(i) for i in input]

result = intList[2]

for i in range(10):
	result = intList[0] * result - intList[1] 
	print(result)

Solution (Python):


r, D, X = map(int, input().split())
x = r * X - D
for a in range(10):
	
	print("{}".format(x))
	x = r * x - D

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

x=[]
x.append(a)

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

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

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

for i in range(2000, 2010):
    x_ans = r * x_temp - D
    print(x_ans)
    x_temp = x_ans

Solution (Python):
import numpy as np

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

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

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

xs = []
xs.append(x2000)
for i in range(10):
    x = r * xs[i] - d
    print(x)
    xs.append(x)

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

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

Solution (Python):
def algae(r: int, D: int, x2000: int)->int:
    x = x2000

    res = []
    for _ in range(10):
        x = r*x - D
        res.append(x)

    return res


if __name__ == "__main__":
    r, D, x2000 = map(int, input().split())

    for ans in algae(r, D, x2000):
        print(ans)

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

Solution (Python):
from sys import exit
r,d,prev=map(int,input().split())


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

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

Solution (Python):
r, D, x = map(lambda x: int(x), 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 i in range(10):
    x = x * r - d
    print(str(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())
d = a*c - b
print(d)
for i in range(9):
  d = a*d - b
  print(d)

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

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

Solution (Python):
r,D,X0 = (int(i) for i in input().split())
X=X0
for num in range(10):
  X=r*X-D
  print('%d'%X)

Solution (Python):
def main():
    rdx = list(map(int, input().split()))
    r, d, x = rdx[0], rdx[1], rdx[2]
    ans = 0
    arr = []
    for i in range(10):
        if i == 0:
            ans = r * x - d
        else:
            ans = r * arr[i-1] - d
        print(ans)
        arr.append(ans)
main()

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


def rec(i, p):
    n = r*p-d
    print(n)
    if i >= 10:
        return
    return rec(i+1, n)


rec(1, int(rdx[2]))

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

ans = [r*x_2000-D]

for _ in range(9):
  ans.append(r*ans[-1]-D)

[print(v) for v in ans]

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

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

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

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

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

x=[x0]

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

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

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

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

for i in range(10):
    if i == 0:
        calc = r * x - d
        ans[i] = calc
    else:
        calc = r * ans[i-1] - d
        ans[i] = calc

print(*ans, sep='\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):
  z = r*x - D
  print(z)
  x = z

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

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

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

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

Solution (Python):


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

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

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

previous_term = x_2000
target_term = 0
for i in range(10):
    target_term = r * previous_term - D
    print(target_term)
    previous_term = target_term

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

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

Solution (Python):
r, d, x = map(int, input().split())
x1 = r*x - d
x2 = r*x1 - d
x3 = r*x2 - d
x4 = r*x3 - d
x5 = r*x4 - d
x6 = r*x5 - d
x7 = r*x6 - d
x8 = r*x7 - d
x9 = r*x8 - d
x10 = r*x9 - d
print(x1)
print(x2)
print(x3)
print(x4)
print(x5)
print(x6)
print(x7)
print(x8)
print(x9)
print(x10)

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

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

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

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

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

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

previous_term = x_2000
target_term = 0
for i in range(10):
    target_term = r * previous_term - D
    print(target_term)
    previous_term = target_term

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

Solution (Python):
from sys import stdin
r,D,x=[int(x) for x in stdin.readline().rstrip().split()]
ans=[x]+[0]*10
for i in range(1,11):
    ans[i] = r * ans[i-1] - D
for j in ans[1:11]:
    print(int(j))

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

Solution (Python):
A = list(map(int, input().split())) 
r = A[0]
D = A[1]
f = A[2]
 
 
count = 0
ans = 0
 
for i in range(10):
    f = (r*f) - D 
    count = count + 1
    print(f)
    if(count == 10):
        break

Solution (Python):
import sys

r, d, x = sys.stdin.readline().rstrip().split(' ')
r, d, x = int(r), int(d), int(x)
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):
def main():
    r,D,x = [int(element) for element in input().split(" ")]
    for i in range(10):
        x = r*x - D
        print(x)

if __name__ =='__main__':
    main()

Solution (Python):
r, D, x_0 = map(int, input().split())
l = [x_0]
for i in range(10):
  x= r * l[-1] - D
  l.append(x)
for j in range(10):
  print(l[j+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, C = (int(i) for i in input().split())

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