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



Sample input:
2 10 20


Sample output:
30
50
90
170
330
650
1290
2570
5130
10250

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
parents = list(map(int,input().split(' ')))

r = parents[0]
D = parents[1]
start = parents[2]

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def growup_rate(r, D, x):
    x = r * x - D
    return x

Input = input().split()
r = int(Input[0])
D = int(Input[1])
x = int(Input[2])

for i in range(10):
    x = growup_rate(r, D, x)
    print(int(x))

Submission status: Accepted

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

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


main()

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import sys

input = sys.stdin.readline

def main():
    r, D, prev_x = [int(e) for e in input().split()]
    for i in range(1, 11):
        res = r * prev_x - D
        print(res)
        prev_x = res

main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(1000000)
 
r,D,x = map(int,input().split())

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

Submission status: Accepted

Solution code:
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
else:
    _str = str
    str = lambda x=b"": x if type(x) is bytes else _str(x).encode()



# ///==========Libraries, Constants and Functions=============///

inf = float("inf")
mod = 10**9+7

#from collections import deque, Counter, OrderedDict,defaultdict
#from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
#from math import ceil,floor,log,sqrt,factorial,pow,pi
#from bisect import bisect_left,bisect_right
#from decimal import *,threading

def dmain():
    sys.setrecursionlimit(100000000)
    threading.stack_size(40960000)
    thread = threading.Thread(target=main)
    thread.start()
    

abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod,MOD=1000000007,998244353
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def getKey(item): return item[0] 
def sort2(l):return sorted(l, key=getKey)
def d2(n,m,num):return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo (x): return (x and (not(x & (x - 1))) )
def decimalToBinary(n): return bin(n).replace("0b","")
def ntl(n):return [int(i) for i in str(n)]

def gcd(x, y):
    while y:
        x, y = y, x % y
    return x


def factorial_p(n, p):
    ans = 1
    if n <= p // 2:
        for i in range(1, n + 1):
            ans = (ans * i) % p
    else:
        for i in range(1, p - n):
            ans = (ans * i) % p
        ans = pow(ans, p - 2, p)
        if n % 2 == 0:
            ans = p - ans
    return ans

def nCr_p(n, r, p):
    ans = 1
    while (n != 0) or (r != 0):
        a, b = n % p, r % p
        if a < b:
            return 0
        ans = (ans * factorial_p(a, p) * pow(factorial_p(b, p), p - 2, p) * pow(factorial_p(a - b, p), p - 2, p)) % p
        n //= p
        r //= p
    return ans

def prime_sieve(n):
    """returns a sieve of primes >= 5 and < n"""
    flag = n % 6 == 2
    sieve = bytearray((n // 3 + flag >> 3) + 1)
    for i in range(1, int(n**0.5) // 3 + 1):
        if not (sieve[i >> 3] >> (i & 7)) & 1:
            k = (3 * i + 1) | 1
            for j in range(k * k // 3, n // 3 + flag, 2 * k):
                sieve[j >> 3] |= 1 << (j & 7)
            for j in range(k * (k - 2 * (i & 1) + 4) // 3, n // 3 + flag, 2 * k):
                sieve[j >> 3] |= 1 << (j & 7)
    return sieve

def prime_list(n):                            #<----- You have to call me if you wanna get list of primes upto range n
    """returns a list of primes <= n"""
    res = []
    if n > 1:
        res.append(2)
    if n > 2:
        res.append(3)
    if n > 4:
        sieve = prime_sieve(n + 1)
        res.extend(3 * i + 1 | 1 for i in range(1, (n + 1) // 3 + (n % 6 == 1)) if not (sieve[i >> 3] >> (i & 7)) & 1)
    return res

def is_prime(n):
    """returns True if n is prime else False"""
    if n < 5 or n & 1 == 0 or n % 3 == 0:
        return 2 <= n <= 3
    s = ((n - 1) & (1 - n)).bit_length() - 1
    d = n >> s
    for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
        p = pow(a, d, n)
        if p == 1 or p == n - 1 or a % n == 0:
            continue
        for _ in range(s):
            p = (p * p) % n
            if p == n - 1:
                break
        else:
            return False
    return True


def all_factors(n):
    """returns a sorted list of all distinct factors of n"""
    small, large = [],[]
    for i in range(1, int(n**0.5) + 1, 2 if n & 1 else 1):
        if not n % i:
            small.append(i)
            large.append(n//i)
    large.reverse()
    small.extend(large)
    return small

def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()

#======================================================================================================

def main():
	r,d,x=get_ints()
	for i in range(10):
		print(r*x-d)
		x=r*x-d
		
# region fastio===================================================================================================================

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        if self.buffer.tell():
            return self.buffer.read()
        return os.read(self._fd, os.fstat(self._fd).st_size)

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", b" "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", b"\n"))
    if kwargs.pop("flush", False):
        file.flush()


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

# endregion=========================================================================================================

# ///===========MAIN=============///

if __name__ == "__main__":
    main()
    #dmain()

Submission status: Accepted

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

x_i = x

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

r, D, x_2000 = map(int, raw_input().split())

_x_i = x_2000

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

for i in range(2,12):
    print(int((r**(i-1))*(x+D/(1-r))-D/(1-r)))

Submission status: Accepted

Solution code:
r,D,x2000=[int(x) for x in input().split()]
x=[x2000]
for i in range(10):
    x.append(x[i]*r-D)
for xi in x[1:]:
    print(xi)

Submission status: Accepted

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

r, D, x = [int(i) for i in input().split()]
n=2000
while True:
    n += 1
    if n > 2010:
        break
    x=next(r, D, x)
    print(x)

Submission status: Accepted

Solution code:
# coding: UTF-8
import sys
#sys.setrecursionlimit(n)
import heapq
import re
import bisect
import random
import math
import itertools
from collections import defaultdict, deque
from copy import deepcopy
from decimal import *

readl= lambda: list(map(int, sys.stdin.readline().split()))
readt= lambda: tuple(map(int, sys.stdin.readline().split()))
read = lambda: sys.stdin.readline().rstrip()
readi = lambda: int(read())
readmi = lambda: map(int, sys.stdin.readline().split())
readms = lambda: map(str, sys.stdin.readline().split())

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# coding: utf-8

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

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

Submission status: Accepted

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

ans = x

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

Submission status: Accepted

Solution code:
r, D, x2000 = map(int, input().split())
xi = x2000
for i in range(0, 10):
    xi1 = r * xi - D
    print("{}".format(xi1))
    xi = xi1

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
data = [int(s) for s in input().split()]
x = data[2]
for i in range(10):
    x = data[0] * x - data[1]
    print(x)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
r, d, x2000 = map(int, raw_input().split())
# 文字列の入力
#s = raw_input()
# 出力

def xiplus1(r,d,x,i):
    if(i < 2010):
        x = r*x - d
        print x
        xiplus1(r,d,x,i+1)

xiplus1(r,d,x2000,2000)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
r, D, x2000 = map(int, input().split())
cur = x2000
for _ in range(10):
    cur = r * cur - D
    print(cur)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
r, D, weight = map(int, input().split())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
r, D, xn = map(int, input().split(' '))

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

Submission status: Accepted

Solution code:
r,D,x = map(int,raw_input().split(' '))
for _ in range(10):
	t = (x*r)-D
	x = t
	print t

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin
import numpy as np
# import math
# import random
# import fractions
# import sys
# sys.setrecursionlimit(100000)
# N = int(stdin.readline().rstrip().split()[0])
# A = [int(x) for x in stdin.readline().rstrip().split()]
# N, X = [int(x) for x in stdin.readline().rstrip().split()]
# S = stdin.readline().rstrip().split()[0]
r, D, x = [int(x) for x in stdin.readline().rstrip().split()]

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

for i in range(10):
  x = f(x)
  print(x)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
r, D, xinit =map(int,input().split())

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

Submission status: Accepted

Solution code:
inp = input()
st = inp.split()
r = int(st[0])
d = int(st[1])
x = int(st[2])
for i in range(10):
    x = r * x - d
    print(int(x))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#b.py
r,d,x= map(int,input().split())

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a = list(map(int,input().split())) #input from array of integer like "1 2 3"

x = []
for i in range(10):
  if i == 0:
    x.append(a[0]*a[2]-a[1])
  else:
    x.append(a[0]*x[i-1]-a[1])
  print(x[i])

Submission status: Accepted

Solution code:
x = [0]*20
r,D,x[0]=map(int,input().split())

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

    print(x[i+1])

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys  
input = sys.stdin.readline

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def i_input(): return int(input())
def s_input(): return map(int,input().split())
def l_input(): return list(map(int, input().split()))

r, D, x = l_input()

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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()

Submission status: Accepted

Solution code:
r,D,x = map(int,input().split())
x_follow = []
for i in range(10):
    x = r*x - D
    x_follow.append(x)
for i in x_follow:
    print(i)

Submission status: Accepted

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

r = li[0]
D = li[1]
x = li[2]

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

Submission status: Accepted

Solution code:
from collections import Counter
from collections import deque
from functools import reduce
from pprint import pprint
# import statistics
import bisect
import copy
import fractions
import math
import random
import sys
import time
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) 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 MI(): return map(int, sys.stdin.readline().split())
def II(): return int(sys.stdin.readline())
def IS(): return input()
def C(x): return Counter(x)
def GCD_LIST(numbers):
    return reduce(fractions.gcd, numbers)
def LCM_LIST(numbers):
    return reduce(LCM, numbers)
def LCM(m, n):
    return (m * n // fractions.gcd(m, n))
def unite(x, y):
    # それぞれのノードの根を求める
    x = root(x)
    y = root(y)
    if x == y:
        return
    # node[x]の根をyに変更する
    node[x] = y
def same(x,y): return bool(root(x) == root(y))
def root(x):
    if node[x] == x:  # xが根の場合
        return x
    else:
        node[x] = root(node[x])  # 経路圧縮
        return node[x]
def dfs(v):
    # ノードに訪れた
    visited[v] = True
    for v2 in range(n):
        if graph[v][v2] == False:  # そもそもvとv2が辺でつながっていない
            continue
        if visited[v2] == True:  # もう見た
            continue
        dfs(v2)

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
flag=False
cnt=0
r,D,x=map(int,input().split())
while cnt<10:
    tmp=x
    x=r*tmp-D
    print(x)
    cnt+=1

Submission status: Accepted

Solution code:
data = list(map(int, input().split()))

r = data[0]
d = data[1]
x = data[2]

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

Submission status: Accepted

Solution code:

x = [0] * 11

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

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

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

Submission status: Accepted

Solution code:
from sys import stdin

def main():
    r,d,x = [int(x) for x in stdin.readline().rstrip().split()]
    curr = x
    for _ in range(10):
        curr = r * curr - d
        print(curr)
    
if __name__=='__main__':
    main()

Submission status: Accepted

Solution code:
# coding:utf-8

import math
import re

def main(params):
    r,d,x = params[0].split()
    r = int(r)
    d = int(d)
    x = int(x)
    base = 2000
    for i in range(1,11):
        newX = r * x - d
        print newX
        x = newX
#    a = params[1].split()
#    b = list(params[2])

if __name__ == "__main__":
    cnt = 1 # TODO: edit here
    params = []
    for i in range(cnt):
        param = raw_input()
        params.append(param)
    main(params)

Submission status: Accepted

Solution code:
li = input().split()
r = int(li[0])
D = int(li[1])
x = int(li[2])
for i in range(10):
    x = r * x - D
    print(x)

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys
import bisect
from collections import defaultdict

ans=0
#n=int(input())
r,d,x=map(int,input().split())

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

Submission status: Accepted

Solution code:
from __future__ import print_function
# import numpy as np
# import numpypy as np
import sys
import math
import string
import fractions
import re
import array
import copy
import functools
import operator

import collections
import itertools
import bisect
import heapq


from heapq import heappush
from heapq import heappop

# from itertools import accumulate
# from collections import deque
import random




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


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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def main():
    """
    x(i+1)=r * x(i)−D
    2001
    2010
    """
    r, D, x2000 = map(int, input().split())

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""



"""
import sys


def solve(r, D, x):
    ans = []
    for i in range(10):
        x = r*x - D
        x = max(x, 0)
        ans.append(x)
    return ans


def main(args):
    r, D, x = map(int, input().split())
    ans = solve(r, D, x)
    print(*ans, sep='\n')


if __name__ == '__main__':
    main(sys.argv[1:])

Submission status: Accepted

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

Submission status: Accepted

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


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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import numpy as np
words = lambda t : list(map(t, input().split()))
r,d,x1 = words(int)

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

Submission status: Accepted

Solution code:
r,D,x_0 = map(int,input().split())
x_cur = x_0
for i in range(10):
  x_next = r*x_cur - D
  print(x_next)
  x_cur = x_next

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n,m,k=list(map(int,input().split()))
a=[k]
for i in range(10):
    s=n*a[-1]-m
    a.append(s)
    print(a[-1])

Submission status: Accepted

Solution code:
from sys import stdin
r, D, x2000 = [int(_) for _ in stdin.readline().rstrip().split()]
ans = x2000
for i in range(10):
    ans = r*ans-D
    print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
r, d, x2k = [ int(v) for v in input().split() ]
algae_last_year = x2k
for i in range(10):
	algae = r * algae_last_year - d
	print(algae)
	algae_last_year = algae

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
r, d, x = map(int, input().split())
for i in range(10):
  x = r * x -d
  print(x)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3.4

# abc127_b

import itertools

def main():
    # Input
    r, d, x2000 = [int(s) for s in input().split()]
    # Get ans
    ans = list(range(11))
    ans[0] = x2000
    def func(xi, xj):
        return r*xi - d
    ans = list(itertools.accumulate(ans, func))
    # Output
    for i in range(1, 11):
        print(ans[i])

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def solve(r, d, x0):
    x = []
    y = x0
    for _ in range(10):
        y = r * y - d
        print(y)
        
r, d, x0 = map(int, input().split())
solve(r, d, x0)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
from io import StringIO
from collections import *
from functools import *
import sys


def main(inputs):
    # n = int(next(inputs))
    # n, k = map(int, next(inputs).split())
    # xs = list(map(int, next(inputs).split()))
    r, d, x = map(int, next(inputs).split())
    for i in range(10):
        x = r*x-d
        print(x)
        pass
    return


def gen_inputs(str_=None):
    inputs = StringIO(str_) if str_ else sys.stdin
    while True:
        a = inputs.readline().rstrip()
        yield a
        pass
    pass


if __name__ == "__main__":
    main(gen_inputs())
    pass

Submission status: Accepted

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


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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
r, D, xi = map(int, input().split())

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

Submission status: Accepted

Solution code:
import sys

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

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

Submission status: Accepted

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

hoge = [x]

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3



# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    # Failed to predict input format

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

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
[r,D,x_ini] = list(map(int, input().split()))
#[r,D, x_ini] = [4, 40, 60]
x = x_ini
for i in range(10):
    x = r*x - D
    print(x)

Submission status: Accepted

Solution code:
# coding: utf-8
import time
import os
import time
import re
import math


r,D,x2000 = map(int,input().split())
now=x2000
for a in range(10):
    now=now*r-D
    print(now)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
r, D, xo = map(int,input().split(" "))

def func(x):
    y = r * x - D
    return y

x = xo

for i in range(10):
    x = func(x)
    print(int(x))