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):
def main():
    r, D, x = map(int, input().split())
    ans = []
    for _ in range(10):
        x = r * x - D
        ans.append(str(x))
    print("\n".join(ans))


if __name__ == '__main__':
    main()

Solution (Python):
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

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

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

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

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

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

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

Solution (Python):
r,D,x = (int(x) for x in input().split())
Disp = [0]*11
Disp[0] = x
for T in range(0,10):
    Disp[T+1] = r*Disp[T]-D
print('\n'.join(str(x) for x in Disp[1:]))

Solution (Python):
import sys
sys.setrecursionlimit(10**7) 
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque, defaultdict


from collections import Counter

from itertools import accumulate,combinations,permutations

from heapq import heapify,heappop,heappush


from functools import reduce,lru_cache

from decimal import Decimal

def input(): 
    x=sys.stdin.readline()
    return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
    mod = 1000000007
    

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

ans=[0 for i  in range(10)]
ans[0]=initial*r-D


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

for anss in ans:
    print(anss)

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):
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())
a = X

for n in range(10):
  a = R*a-D
  print(a)

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):
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
from decimal import Decimal
from operator import mul

INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)



class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


def dijkstra_heap(s, edge, n):
    
    d = [10**20] * n
    used = [True] * n 
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr


def combinations_count(n, r):
    if n < r:
        return 0
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


def lcm(x, y):
    return (x * y) // gcd(x, y)


def lcm_list(numbers):
    return reduce(lcm, numbers, 1)


def gcd_list(numbers):
    return reduce(gcd, numbers)


def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True



def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P


def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret

def make_divisors(n):
    lower_divisors , upper_divisors = [], []
    i = 1
    while i*i <= n:
        if n % i == 0:
            lower_divisors.append(i)
            if i != n // i:
                upper_divisors.append(n//i)
        i += 1
    return lower_divisors + upper_divisors[::-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, input().split())

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

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_2001 = r *x_2000 -D

memo = {2000: x_2000, 2001: x_2001}


def zen(n, x, r, D):
    x.append(r *x[n -1] -D)
    return x

x = []
x.append(x_2000)
for i in range(1, 11):
    print(zen(i, x, r, D)[-1])

Solution (Python):
import math
import sys
input = sys.stdin.readline
X = [int(_) for _ in range(2500)]
r, d, x = map(int, input().split())
X[2000] = x
for i in range(2001, 2011):
    X[i] = r * X[i - 1] - d
[print(X[i]) for i in range(2001,2011)]

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

if __name__ == "__main__":
    main()

Solution (Python):
r,d,x_s = map(int,input().split())
x = x_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(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):
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())

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

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

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

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

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

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

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

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

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

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

def mo(i):
    if i == 0:
        return x0
    return r*mo(i-1) - d 

for i in range(1,11):
    print(mo(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())

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

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

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

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

Solution (Python):
cnt = 0
def f(n,r,d):
  global cnt
  n = r*n-d
  print(n)
  cnt += 1
  if cnt < 10:
  	f(n,r,d)
r,d,x = map(int,input().split())
f(x,r,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):
r,D,x=map(int,input().split())
for i in range(10):
    print(r*x-D,sep="")
    x=r*x-D

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

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

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

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

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

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

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

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

Solution (Python):
import sys, os, math, bisect, itertools, collections, heapq, queue

from decimal import Decimal
from collections import defaultdict



sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)


MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    r, D, x = il()

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



if __name__ == '__main__':
    main()

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

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

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

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

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

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

try:
    r,D,x_2000=map(int, input().split())
    assert 2<=r<=5 and 1<=D<=100 and D<x_2000<=200

    for i in range(2001,2011):
        print(r*x_2000-D)
        x_2000=r*x_2000-D
except AssertionError:
    print('')

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

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

for y in range(2001, 2011):
    x2000 = x2000*r - d
    print(x2000)

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



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








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

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

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

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

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

Solution (Python):
a,b,c=map(int,input().split())
def f(n):
  if(n==2000):
    return(c);
  return(a*(f(n-1))-b)
for i in range (2001,2011):
  print(f(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 _ in range(10):
  x = r*x - d
  print(x)

Solution (Python):

import sys
input = sys.stdin.readline
r,D,x2000 = (int(i) for i in input().split())
x =[0]*11
x[0] =x2000
for i in range(10):
    x[i+1] =r*x[i] -D
    print(x[i+1])

Solution (Python):
inp=input()
list=inp.split()
r,D,x=list[0], list[1], list[2]
for i in range(10):
  ans=(int(x)*int(r))-int(D)
  x=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):


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

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

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

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

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

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

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

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

if __name__ == '__main__':
    solve()

Solution (Python):
import sys
a=sys.stdin.readline()
res = [int(i) for i in a.split() if i.isdigit()] 
r,D,x2000 = [res[i] for i in (0,1,2)]
if (r>=2 and r<=5) and (D>=1 and D<=100) and (x2000>D and x2000<=200):
    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)
else:
    print("Error")

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60


def main():
    r, D, x = map(int, readline().split())
    for _ in range(10):
        x = r * x - D
        print(x)
    
    return


if __name__ == '__main__':
    main()

Solution (Python):
c = [int(i) for i in input().split() if i.isdigit()] 
for i in range(1,11):
    c[2] = (c[0] * c[2]) - c[1]
    print(c[2])

Solution (Python):
r,d,x= input().split()
r = int(r)
d =int(d)
x =int(x)
i=1
while i<11:
  i+=1
  x = r*x - d
  print(x)

Solution (Python):
r,d,x= input().split()
r = int(r)
d =int(d)
x =int(x)
i=1
while i<11:
  i+=1
  x = r*x - d
  print(x)

Solution (Python):
r,d,x=map(int,input().split())
listr=[]
while len(listr)<=9:
  x=r*x-d
  listr.append(x)
  
[print(i) for i in listr]

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

def getx(f):
      return r*f-d

for i in range(2001, 2011):
      x = getx(x)
      print(x)

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

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

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

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

l = [s]
for i in range(1,11):
    xi = algae(r, D, l[i-1])
    l.append(xi)
    print(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):
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())

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

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

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

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

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

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

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

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

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

def num(i):
    return r*i-D

a = x
for i in range(10):
    a = num(a)
    print(a)

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

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

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

Solution (Python):
from sys import stdin, setrecursionlimit


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


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

Solution (Python):
r,d,x = map(int, raw_input().split(' '))
q = 10
while(q):
  x = r*x - d
  print x
  q-=1

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 = lambda: sys.stdin.readline().rstrip()


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

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


if __name__ == '__main__':
    solve()

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

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

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

L = [x]
for i in range(1,11):
  L.append(L[i-1]*r - d)
  
L.pop(0)
for i in range(len(L)):
  print(L[i])

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

Solution (Python):
def actual(r, D, x_2000):
    x_list = []
    x_n = x_2000

    for _ in range(1, 10 + 1):
        x_next = r * x_n - D
        x_n = x_next

        x_list.append(x_next)

    return '\n'.join([str(x) for x in x_list])

r, D, x_2000 = map(int, input().split())
print(actual(r, D, x_2000))

Solution (Python):
def i():
	return int(input())
def i2():
	return map(int,input().split())
def s():
	return str(input())
def l():
	return list(input())
def intl():
	return list(int(k) for k in input().split())

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

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

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

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

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):
r,d,x0 = map(int,input().split())
ans = [0] * 11
ans[0] = x0
for i in range(10):
    ans[i + 1] = r * ans[i] - d 
    print(ans[i + 1])

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

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

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

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

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
r, d, x = M()
temp = x
for _ in range(10):
    a = temp*r-d
    temp = a
    print(a)

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

for i in range(10):
    print(p[i])

Solution (Python):

def s0():return input()
def s1():return input().split()
def s2(n):return [input() for x in range(n)]
def s3(n):return [input().split() for _ in range(n)]
def s4(n):return [[x for x in s] for s in s2(n)]
def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
def t3(n):return [tuple(int(x) for x in input().split()) for _ in range(n)]
def p0(b,yes="Yes",no="No"): print(yes if b else no)








r,d,x = n1()

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

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

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

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

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

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

Solution (Python):
r,t,x=map(int,input().split())
a=r*x-t
b=r*a-t
c=r*b-t
d=r*c-t
e=r*d-t
f=r*e-t
g=r*f-t
h=r*g-t
i=r*h-t
j=r*i-t
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
print(g)
print(h)
print(i)
print(j)

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

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

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

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

ans = [x_2000]

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

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

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

    ans = [0 for _ in range(11)]
    ans[0] = x
    for i in range(1, 11):
        ans[i] = r * ans[i-1] - D

    print('\n'.join(map(str, ans[1:])))


resolve()

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

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

ans = []
tmp = r*x - d
ans.append(tmp)
print(tmp)
for i in range(0,9):
  x_i = ans[i]
  tmp = r*x_i - d
  ans.append(tmp)
  print(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 = (int(a) for a in input().split())
count = 0
while count <= 9 :
    x = r * x - D
    print(x)
    count += 1

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

Solution (Python):

def rec(Xi,cnt):
    if cnt>=10:
        return

    Xnext = r*Xi-D
    print(Xnext)
    rec(Xnext,cnt+1)

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

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

Solution (Python):
from sys import stdin
def LI(): return list(map(int,stdin.readline().rstrip().split()))

tmp = LI()
r,d,x = [tmp.pop(0) for _ in range(3)]

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

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

Solution (Python):
def solve():
  r, d, x = map(int, input().split())
  for i in range(10):
    x = r*x-d
    print(x)
  return 0
 
if __name__ == "__main__":
  solve()

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())
ans =''

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

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

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

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

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