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:
# -*- coding: utf-8 -*-
# IMPORT ###############################################################################################################
import sys                                                      # システム
sys.setrecursionlimit(10**6)                                    # 再帰処理の上限変更
from collections import deque, Counter                          # キュー・個数カウント
from itertools   import accumulate, permutations, combinations  # 累積和・順列・組み合わせ
from operator    import itemgetter                              # ソート補助
from bisect      import bisect_left, bisect_right, bisect       # 二分探索
from heapq       import heappop, heappush                       # プライオリティキュー
from fractions   import gcd                                     # 最大公約数
from math        import ceil, floor, sqrt, cos, sin, tan, pi    # 数学処理
from copy        import deepcopy                                # オブジェクトコピー
import numpy         as np                                      # 数値計算

# MAIN #################################################################################################################
def main():
    # Init #############################################################################################################
    im = InputManager()
    # Input ############################################################################################################
    r, d, x_2000 = im.inputMultiple()
    # Logic ############################################################################################################
    x_next = x_2000
    for _ in range(10):
        x_next = r * x_next - d
        print(x_next)
    # Output ###########################################################################################################

    # Return ###########################################################################################################
    return

# INPUT MANAGER ########################################################################################################
class InputManager(object):
    def __init__(self):
        pass

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

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

# CALL MAIN ############################################################################################################
main()

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

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

Submission status: Accepted

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

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

r,d,x = na()

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()

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


main()

Submission status: Accepted

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

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

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


r,d,x = m()

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

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

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

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

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

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

Submission status: Accepted

Solution code:
# coding: utf-8

import sys
import math

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

sys.setrecursionlimit(1000000)


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

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

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

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

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


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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

r, d, x = nm()

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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:
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


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


def ceil(a, b):
    return (a + b - 1) // b


# aとbの最大公約数
def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)

# aとbの最小公倍数
def lcm(a, b):
    g = gcd(a, b)
    return a / g * b


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

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

Submission status: Accepted

Solution code:
#JMD
#Nagendra Jha-4096

 
import sys
import math

#import fractions
#import numpy
 
###File Operations###
fileoperation=0
if(fileoperation):
    orig_stdout = sys.stdout
    orig_stdin = sys.stdin
    inputfile = open('W:/Competitive Programming/input.txt', 'r')
    outputfile = open('W:/Competitive Programming/output.txt', 'w')
    sys.stdin = inputfile
    sys.stdout = outputfile

###Defines...###
mod=1000000007
 
###FUF's...###
def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 
 
##### Main ####
t=1
for tt in range(t):
    #n=int(input())
    r,d,x= map(int, sys.stdin.readline().split(' '))
    for i in range(10):
        x=r*x - d
        print(x)
    #a=list(map(int,sys.stdin.readline().split(' ')))
    
    
#####File Operations#####
if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:

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

ans=[x]

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

for i in range(10):
    print(ans[i+1])

Submission status: Accepted

Solution code:
r,D,x0 = map(int,input().split())
X = [x0]
for i in range(10):
    nx = r*X[-1] - D
    X.append(nx)

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

Submission status: Accepted

Solution code:
import sys
#import numpy as np

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in ss]
ss2nnn = lambda ss: [s2nn(s) for s in ss]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline().rstrip() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    r, D, x = i2nn()
    for _ in range(10):
        x = (r * x) - D
        print(x)

main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
r,d,x=map(int,input().split())
tmp=x
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()]

for _ 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:
r,d,x = map(int,input().split())
ans = x
for i in range(10):
    ans = ans*r-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:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import random

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)


def main():
    a,b,c = LI()
    r = [c]
    for i in range(10):
        r.append(a*r[-1]-b)

    return '\n'.join(map(str, r[1:]))


print(main())

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:
#!/usr/bin/env python3
import sys
INF = float("inf")


def main():
    r, D, x2000 = map(int, input().split())
    currx = x2000
    for i in range(10):
        currx = r*currx - D
        print(currx)
    pass


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def inpl(): return map(int, input().split())

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

Submission status: Accepted

Solution code:

def main():
    buf = input()
    buflist = buf.split()
    r = int(buflist[0])
    D = int(buflist[1])
    x2000 = int(buflist[2])
    x = x2000
    for i in range(10):
        x = r * x - D
        print(x)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

result = x

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

Submission status: Accepted

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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    from sys import stdin, stdout

    def read():
        return stdin.readline().rstrip('\n')

    def read_array(sep=None, maxsplit=-1):
        return read().split(sep, maxsplit)

    def read_int():
        return int(read())

    def read_int_array(sep=None, maxsplit=-1):
        return [int(a) for a in read_array(sep, maxsplit)]

    def write(*args, **kwargs):
        sep = kwargs.get('sep', ' ')
        end = kwargs.get('end', '\n')
        stdout.write(sep.join(str(a) for a in args) + end)

    def write_array(array, **kwargs):
        sep = kwargs.get('sep', ' ')
        end = kwargs.get('end', '\n')
        stdout.write(sep.join(str(a) for a in array) + end)

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

main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10**7)

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
r, d, x = [int(_) for _ in raw_input().split()]
for _ in xrange(10):
    x = x*r - d
    print x

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
inf = float('inf')
mod = 10**9+7


def INT_(n): return int(n)-1


def MI(): return map(int, input().split())


def MF(): return map(float, input().split())


def MI_(): return map(INT_, input().split())


def LI(): return list(MI())


def LI_(): return [int(x) - 1 for x in input().split()]


def LF(): return list(MF())


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


def LLIN(n: int): return [LI() for _ in range(n)]


def LLIN_(n: int): return [LI_() for _ in range(n)]


def LLI(): return [list(map(int, l.split())) for l in input()]


def I(): return int(input())


def F(): return float(input())


def ST(): return input().replace('\n', '')


def main():
    r, D, x = MI()
    for _ in range(10):
        x = (x * r) - D
        print(x)


if __name__ == '__main__':
    main()

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:
# https://atcoder.jp/contests/abc127/tasks/abc127_b

import itertools
from collections import Counter
from collections import defaultdict
import bisect

def main():
    r, D, X = map(int, input().split())
    xi = X
    for i in range(1, 11):
        xi = r * xi - D
        print(xi)

if __name__ == '__main__':
    main()

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:
# /usr/bin/python
# -*- coding: utf-8 -*-




r,d,x = map(int, input().split())
for _ 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:
###############################################################################

from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy
from collections import defaultdict


mod = 1


def intin():
    input_tuple = input().split()
    if len(input_tuple) <= 1:
        return int(input_tuple[0])
    return tuple(map(int, input_tuple))


def intina():
    return [int(i) for i in input().split()]


def intinl(count):
    return [intin() for _ in range(count)]


def modadd(x, y):
    global mod
    return (x + y) % mod


def modmlt(x, y):
    global mod
    return (x * y) % mod


def lcm(x, y):
    while y != 0:
        z = x % y
        x = y
        y = z
    return x


def combination(x, y):
    assert(x >= y)

    if y > x // 2:
        y = x - y

    ret = 1

    for i in range(0, y):
        j = x - i
        i = i + 1

        ret = ret * j
        ret = ret // i

    return ret


def get_divisors(x):
    retlist = []
    for i in range(1, int(x**0.5) + 3):
        if x % i == 0:
            retlist.append(i)
            retlist.append(x // i)
    return retlist


def get_factors(x):
    retlist = []
    for i in range(2, int(x**0.5) + 3):
        while x % i == 0:
            retlist.append(i)
            x = x // i
    retlist.append(x)
    return retlist


def make_linklist(xylist):
    linklist = {}
    for a, b in xylist:
        linklist.setdefault(a, [])
        linklist.setdefault(b, [])
        linklist[a].append(b)
        linklist[b].append(a)
    return linklist


def calc_longest_distance(linklist, v=1):
    distance_list = {}
    distance_count = 0
    distance = 0
    vlist_previous = []
    vlist = [v]
    nodecount = len(linklist)

    while distance_count < nodecount:
        vlist_next = []
        for v in vlist:
            distance_list[v] = distance
            distance_count += 1
            vlist_next.extend(linklist[v])
        distance += 1
        vlist_to_del = vlist_previous
        vlist_previous = vlist
        vlist = list(set(vlist_next) - set(vlist_to_del))

    max_distance = -1
    max_v = None
    for v, distance in distance_list.items():
        if distance > max_distance:
            max_distance = distance
            max_v = v

    return (max_distance, max_v)


def calc_tree_diameter(linklist, v=1):
    _, u = calc_longest_distance(linklist, v)
    distance, _ = calc_longest_distance(linklist, u)
    return distance


class UnionFind:

    def __init__(self, n):
        self.parent = [i for i in range(n)]

    def root(self, i):
        if self.parent[i] == i:
            return i
        self.parent[i] = self.root(self.parent[i])
        return self.parent[i]

    def unite(self, i, j):
        rooti = self.root(i)
        rootj = self.root(j)
        if rooti == rootj:
            return
        if rooti < rootj:
            self.parent[rootj] = rooti
        else:
            self.parent[rooti] = rootj

    def same(self, i, j):
        return self.root(i) == self.root(j)


###############################################################################


def main():
    r, d, x = intin()

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
R, D, X = map(int, input().split())
for _ 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 = r * x - d
    print(x)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def run(r, D, x2000):
    x = x2000
    for i in range(10):
        x = r*x - D
        print(x)


def main():
    r, D, x2000 = map(int, input().split())
    run(r, D, x2000)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
import re
import bisect
from datetime import datetime as dt
r, D, X = map(int, input().split())
for i in range(10):
    X = r*X - D
    print(X)

Submission status: Accepted

Solution code:
import sys
from collections import deque
import math
sys.setrecursionlimit(20000000)
#input = sys.stdin.readline
a,b,c = map(int,input().split())
for i in range(10):
    c = a*c-b
    print(c)

Submission status: Accepted

Solution code:
#!/usr/bin/env pypy
from __future__ import division, print_function

import os
import sys
from __builtin__ import xrange as range
from cStringIO import StringIO
from future_builtins import ascii, filter, hex, map, oct, zip
from io import IOBase

import __pypy__


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


# region fastio

BUFSIZE = 8192


class FastI(IOBase):
    def __init__(self, file):
        self._fd = file.fileno()
        self._buffer = StringIO()
        self.newlines = 0

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


class FastO(IOBase):
    def __init__(self, file):
        self._fd = file.fileno()
        self._buffer = __pypy__.builders.StringBuilder()
        self.write = lambda s: self._buffer.append(s)

    def flush(self):
        os.write(self._fd, self._buffer.build())
        self._buffer = __pypy__.builders.StringBuilder()


def print(*args, **kwargs):
    sep, file = kwargs.pop("sep", " "), 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", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


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

# endregion

if __name__ == "__main__":
    main()

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:
from collections import defaultdict


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


if __name__ == '__main__':
    Solution().main()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:

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


if __name__ == '__main__':
    main()

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

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:
import sys, math, collections, heapq, itertools
F = sys.stdin
def single_input(): return F.readline().strip("\n")
def line_input(): return F.readline().strip("\n").split()
def gcd(a, b):
    a, b = max(a, b), min(a, b)
    while a % b > 0: a, b = b, a % b
    return b
  
def solve():
    r, d, x = map(int, line_input())
    ans = x
    for i in range(10):
        ans = r * ans - d
        print(ans)
    return 0
  
if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
ri = lambda: int(input())
rl = lambda: list(map(int,input().split()))
rr = lambda N: [ri() for _ in range(N)]
YN = lambda b: print('YES') if b else print('NO')
yn = lambda b: print('Yes') if b else print('No')
OE = lambda x: print('Odd') if x%2 else print('Even')
INF = 10**18
MOD=10**9+7

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

Submission status: Accepted

Solution code:
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')

#A
def A():
    return

#B
def B():
    r, d, x = LI()
    for i in range(10):
        print(x * r - d)
        x = x * r - d
    return

#C
def C():
    return

#D
def D():
    return

#E
def E():
    return

#F
def F():
    return

#G
def G():
    return

#H
def H():
    return

#Solve
if __name__ == '__main__':
    B()

Submission status: Accepted

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

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