Let S(n) denote the sum of the digits in the decimal notation of n.
For example, S(123) = 1 + 2 + 3 = 6.
We will call an integer n a Snuke number when, for all positive integers m such that m > n, \frac{n}{S(n)} \leq \frac{m}{S(m)} holds.
Given an integer K, list the K smallest Snuke numbers.

-----Constraints-----
 - 1 \leq K
 - The K-th smallest Snuke number is not greater than 10^{15}.

-----Input-----
Input is given from Standard Input in the following format:
K

-----Output-----
Print K lines. The i-th line should contain the i-th smallest Snuke number.

-----Sample Input-----
10

-----Sample Output-----
1
2
3
4
5
6
7
8
9
19


Difficulty: interview

Starter code:

Solutions:
k=int(input())
a=0
b=1
for i in range(k):
  a+=b
  print(a)
  if b<(a+b)/sum(map(int,str(a+b))):
    b*=10

def S(n):
    return sum(map(int, str(n)))


K = int(input())

x = 1
d = 1
while K > 0:
    if S(x) * d < x:
        x += 9 * d
        d *= 10
    else:
        print(x)
        x += d
        K -= 1

K = int(input())


def digit_sum(s):
    return sum([int(i) for i in str(s)])


def f(n):
    n = str(n)
    f_min, f_ans = float('inf'), -1
    for i in range(len(n)):  # 上から何桁目をいじるか
        for x in range(int(n[i]), 10):
            s = n[:i] + str(x) + '9' * (len(n) - i - 1)
            if f_min > int(s) / digit_sum(s):
                f_min = int(s) / digit_sum(s)
                f_ans = int(s)
    return f_ans


ans = [1]
for k in range(K - 1):
    ans.append(f(ans[-1] + 1))

print(*ans, sep='\n')


def cal(n):
    m = n
    ret = 0
    while n != 0:
        ret += n % 10
        n //= 10
    return m/ret

# n以上で s(n) が最小となる整数値
def f(n):
    cand = []
    s = str(n)
    for i in range(len(s)-1,-1,-1):
        if s[i] == "9":
            continue
        for j in range(int(s[i]), 10):
            t = int(s[:i] + str(j) + s[i+1:])
            cand += [ t ]
        s = s[:i] + "9" + s[i+1:]

    ret = n
    for x in cand:
        if cal(x) < cal(ret):
            ret = x
    return ret 


k = int(input())
ans = 1

for _ in range(k):
    print(ans)
    ans = f(ans+1)


k = int(input())

cnt = 0
step = 1
base = 1
tail = ""
now = 0
def f(x):
    s = list(str(x))
    return sum([int(i) for i in s])
while 1:
    now += step
    if now > step*f(now):
        now -= step
        step *= 10
    else:
        cnt += 1
        print(now)
        if cnt == k:
            return
     


K = int(input())


def f(n):
    return n / sum([int(s) for s in str(n)])


ans = [1]
for k in range(K - 1):
    min_f_val, next_snuke = float('inf'), None
    n = str(ans[-1] + 1)

    for i in range(len(n)):
        for x in range(int(n[i]), 10):
            X = n[:i] + str(x) + '9' * (len(n) - i - 1)
            f_val = f(int(X))

            if f_val < min_f_val:
                next_snuke = int(X)
                min_f_val = f_val

    ans.append(next_snuke)

print(*ans, sep='\n')


#!/usr/bin/env python3

def main():
    K = int(input())

    l = []
    for i in range(1, 1000):
        l.append(i)
    for k in range(1, 13):
        n0 = 10 ** k
        for i in range(100, 1000):
            l.append(i * n0 + n0 - 1)

    r = []
    for n in l:
        sn = 0
        d = n
        while 0 < d:
            d, m = int(d / 10), d % 10
            sn += m
        r.append(n / sn)

    min_r = r[-1]
    for i in range(len(r) - 2, -1, -1):
        if min_r < r[i]:
            r.pop(i)
            l.pop(i)
        else:
            min_r = r[i]

    for i in range(K):
        print((l[i]))


def __starting_point():
    main()


__starting_point()

K = int(input())
snuke = [1, 2, 3, 4, 5, 6, 7, 8, 9, 19, 29, 39, 49, 59, 69, 79, 89, 99, 199, 299, 399, 499, 599, 699, 799, 899, 999, 1099, 1199, 1299, 1399, 1499, 1599, 1699, 1799, 1899, 1999, 2999, 3999, 4999, 5999, 6999, 7999, 8999, 9999, 10999, 11999, 12999, 13999, 14999, 15999, 16999, 17999, 18999, 19999, 20999, 21999, 22999, 23999, 24999, 25999, 26999, 27999, 28999, 29999, 39999, 49999, 59999, 69999, 79999, 89999, 99999, 109999, 119999, 129999, 139999, 149999, 159999, 169999, 179999, 189999, 199999, 209999, 219999, 229999, 239999, 249999, 259999, 269999, 279999, 289999, 299999, 309999, 319999, 329999, 339999, 349999, 359999, 369999, 379999, 389999, 399999, 499999, 599999, 699999, 799999, 899999, 999999, 1099999, 1199999, 1299999, 1399999, 1499999, 1599999, 1699999, 1799999, 1899999, 1999999, 2099999, 2199999, 2299999, 2399999, 2499999, 2599999, 2699999, 2799999, 2899999, 2999999, 3099999, 3199999, 3299999, 3399999, 3499999, 3599999, 3699999, 3799999, 3899999, 3999999, 4099999, 4199999, 4299999, 4399999, 4499999, 4599999, 4699999, 4799999, 4899999, 4999999, 5999999, 6999999, 7999999, 8999999, 9999999, 10999999, 11999999, 12999999, 13999999, 14999999, 15999999, 16999999, 17999999, 18999999, 19999999, 20999999, 21999999, 22999999, 23999999, 24999999, 25999999, 26999999, 27999999, 28999999, 29999999, 30999999, 31999999, 32999999, 33999999, 34999999, 35999999, 36999999, 37999999, 38999999, 39999999, 40999999, 41999999, 42999999, 43999999, 44999999, 45999999, 46999999, 47999999, 48999999, 49999999, 50999999, 51999999, 52999999, 53999999, 54999999, 55999999, 56999999, 57999999, 58999999, 59999999, 69999999, 79999999, 89999999, 99999999, 109999999, 119999999, 129999999, 139999999, 149999999, 159999999, 169999999, 179999999, 189999999, 199999999, 209999999, 219999999, 229999999, 239999999, 249999999, 259999999, 269999999, 279999999, 289999999, 299999999, 309999999, 319999999, 329999999, 339999999, 349999999, 359999999, 369999999, 379999999, 389999999, 399999999, 409999999, 419999999, 429999999, 439999999, 449999999, 459999999, 469999999, 479999999, 489999999, 499999999, 509999999, 519999999, 529999999, 539999999, 549999999, 559999999, 569999999, 579999999, 589999999, 599999999, 609999999, 619999999, 629999999, 639999999, 649999999, 659999999, 669999999, 679999999, 689999999, 699999999, 799999999, 899999999, 999999999, 1099999999, 1199999999, 1299999999, 1399999999, 1499999999, 1599999999, 1699999999, 1799999999, 1899999999, 1999999999, 2099999999, 2199999999, 2299999999, 2399999999, 2499999999, 2599999999, 2699999999, 2799999999, 2899999999, 2999999999, 3099999999, 3199999999, 3299999999, 3399999999, 3499999999, 3599999999, 3699999999, 3799999999, 3899999999, 3999999999, 4099999999, 4199999999, 4299999999, 4399999999, 4499999999, 4599999999, 4699999999, 4799999999, 4899999999, 4999999999, 5099999999, 5199999999, 5299999999, 5399999999, 5499999999, 5599999999, 5699999999, 5799999999, 5899999999, 5999999999, 6099999999, 6199999999, 6299999999, 6399999999, 6499999999, 6599999999, 6699999999, 6799999999, 6899999999, 6999999999, 7099999999, 7199999999, 7299999999, 7399999999, 7499999999, 7599999999, 7699999999, 7799999999, 7899999999, 7999999999, 8999999999, 9999999999, 10999999999, 11999999999, 12999999999, 13999999999, 14999999999, 15999999999, 16999999999, 17999999999, 18999999999, 19999999999, 20999999999, 21999999999, 22999999999, 23999999999, 24999999999, 25999999999, 26999999999, 27999999999, 28999999999, 29999999999, 30999999999, 31999999999, 32999999999, 33999999999, 34999999999, 35999999999, 36999999999, 37999999999, 38999999999, 39999999999, 40999999999, 41999999999, 42999999999, 43999999999, 44999999999, 45999999999, 46999999999, 47999999999, 48999999999, 49999999999, 50999999999, 51999999999, 52999999999, 53999999999, 54999999999, 55999999999, 56999999999, 57999999999, 58999999999, 59999999999, 60999999999, 61999999999, 62999999999, 63999999999, 64999999999, 65999999999, 66999999999, 67999999999, 68999999999, 69999999999, 70999999999, 71999999999, 72999999999, 73999999999, 74999999999, 75999999999, 76999999999, 77999999999, 78999999999, 79999999999, 80999999999, 81999999999, 82999999999, 83999999999, 84999999999, 85999999999, 86999999999, 87999999999, 88999999999, 89999999999, 99999999999, 109999999999, 119999999999, 129999999999, 139999999999, 149999999999, 159999999999, 169999999999, 179999999999, 189999999999, 199999999999, 209999999999, 219999999999, 229999999999, 239999999999, 249999999999, 259999999999, 269999999999, 279999999999, 289999999999, 299999999999, 309999999999, 319999999999, 329999999999, 339999999999, 349999999999, 359999999999, 369999999999, 379999999999, 389999999999, 399999999999, 409999999999, 419999999999, 429999999999, 439999999999, 449999999999, 459999999999, 469999999999, 479999999999, 489999999999, 499999999999, 509999999999, 519999999999, 529999999999, 539999999999, 549999999999, 559999999999, 569999999999, 579999999999, 589999999999, 599999999999, 609999999999, 619999999999, 629999999999, 639999999999, 649999999999, 659999999999, 669999999999, 679999999999, 689999999999, 699999999999, 709999999999, 719999999999, 729999999999, 739999999999, 749999999999, 759999999999, 769999999999, 779999999999, 789999999999, 799999999999, 809999999999, 819999999999, 829999999999, 839999999999, 849999999999, 859999999999, 869999999999, 879999999999, 889999999999, 899999999999, 909999999999, 919999999999, 929999999999, 939999999999, 949999999999, 959999999999, 969999999999, 979999999999, 989999999999, 999999999999, 1099999999999, 1199999999999, 1299999999999, 1399999999999, 1499999999999, 1599999999999, 1699999999999, 1799999999999, 1899999999999, 1999999999999, 2099999999999, 2199999999999, 2299999999999, 2399999999999, 2499999999999, 2599999999999, 2699999999999, 2799999999999, 2899999999999, 2999999999999, 3099999999999, 3199999999999, 3299999999999, 3399999999999, 3499999999999, 3599999999999, 3699999999999, 3799999999999, 3899999999999, 3999999999999, 4099999999999, 4199999999999, 4299999999999, 4399999999999, 4499999999999, 4599999999999, 4699999999999, 4799999999999, 4899999999999, 4999999999999, 5099999999999, 5199999999999, 5299999999999, 5399999999999, 5499999999999, 5599999999999, 5699999999999, 5799999999999, 5899999999999, 5999999999999, 6099999999999, 6199999999999, 6299999999999, 6399999999999, 6499999999999, 6599999999999, 6699999999999, 6799999999999, 6899999999999, 6999999999999, 7099999999999, 7199999999999, 7299999999999, 7399999999999, 7499999999999, 7599999999999, 7699999999999, 7799999999999, 7899999999999, 7999999999999, 8099999999999, 8199999999999, 8299999999999, 8399999999999, 8499999999999, 8599999999999, 8699999999999, 8799999999999, 8899999999999, 8999999999999, 9099999999999, 9199999999999, 9299999999999, 9399999999999, 9499999999999, 9599999999999, 9699999999999, 9799999999999, 9899999999999, 9999999999999, 10999999999999, 11999999999999, 12999999999999, 13999999999999, 14999999999999, 15999999999999, 16999999999999, 17999999999999, 18999999999999, 19999999999999, 20999999999999, 21999999999999, 22999999999999, 23999999999999, 24999999999999, 25999999999999, 26999999999999, 27999999999999, 28999999999999, 29999999999999, 30999999999999, 31999999999999, 32999999999999, 33999999999999, 34999999999999, 35999999999999, 36999999999999, 37999999999999, 38999999999999, 39999999999999, 40999999999999, 41999999999999, 42999999999999, 43999999999999, 44999999999999, 45999999999999, 46999999999999, 47999999999999, 48999999999999, 49999999999999, 50999999999999, 51999999999999, 52999999999999, 53999999999999, 54999999999999, 55999999999999, 56999999999999, 57999999999999, 58999999999999, 59999999999999, 60999999999999, 61999999999999, 62999999999999, 63999999999999, 64999999999999, 65999999999999, 66999999999999, 67999999999999, 68999999999999, 69999999999999, 70999999999999, 71999999999999, 72999999999999, 73999999999999, 74999999999999, 75999999999999, 76999999999999, 77999999999999, 78999999999999, 79999999999999, 80999999999999, 81999999999999, 82999999999999, 83999999999999, 84999999999999, 85999999999999, 86999999999999, 87999999999999, 88999999999999, 89999999999999, 90999999999999, 91999999999999, 92999999999999, 93999999999999, 94999999999999, 95999999999999, 96999999999999, 97999999999999, 98999999999999, 99999999999999, 100999999999999, 101999999999999, 102999999999999, 103999999999999, 104999999999999, 105999999999999, 106999999999999, 107999999999999, 108999999999999, 109999999999999, 119999999999999, 129999999999999, 139999999999999, 149999999999999, 159999999999999, 169999999999999, 179999999999999, 189999999999999, 199999999999999, 209999999999999, 219999999999999, 229999999999999, 239999999999999, 249999999999999, 259999999999999, 269999999999999, 279999999999999, 289999999999999, 299999999999999, 309999999999999, 319999999999999, 329999999999999, 339999999999999, 349999999999999, 359999999999999, 369999999999999, 379999999999999, 389999999999999, 399999999999999, 409999999999999, 419999999999999, 429999999999999, 439999999999999, 449999999999999, 459999999999999, 469999999999999, 479999999999999, 489999999999999, 499999999999999, 509999999999999, 519999999999999, 529999999999999, 539999999999999, 549999999999999, 559999999999999, 569999999999999, 579999999999999, 589999999999999, 599999999999999, 609999999999999, 619999999999999, 629999999999999, 639999999999999, 649999999999999, 659999999999999, 669999999999999, 679999999999999, 689999999999999, 699999999999999, 709999999999999, 719999999999999, 729999999999999, 739999999999999, 749999999999999, 759999999999999, 769999999999999, 779999999999999, 789999999999999, 799999999999999, 809999999999999, 819999999999999, 829999999999999, 839999999999999, 849999999999999, 859999999999999, 869999999999999, 879999999999999, 889999999999999, 899999999999999, 909999999999999, 919999999999999, 929999999999999, 939999999999999, 949999999999999, 959999999999999, 969999999999999, 979999999999999, 989999999999999, 999999999999999]
for k in range(K):
    print((snuke[k]))


#!/usr/bin/env python
# coding: utf-8

def ri():
    return int(input())

def rl():
    return list(input().split())

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

def calc(n):
    s = sum(map(int, str(n)))
    return n / s

def f(n):
    ld = list(map(int, str(n)))
    cand = []
    for i in range(len(ld)-1):
        d = len(ld)-1-i
        ld[d] = 9
        for i in range(1, 10):
            if i < ld[d-1]:
                continue
            ld[d-1] = i
            p = int("".join(map(str, ld)))
            cand.append((calc(p), p))
    cand.sort()
    return cand[0][1]

MAX = 10**15
def main():
    k = ri()
    cand = list(range(1, 10))
    n = 10
    while True:
        if n > MAX:
            break
        p = f(n)
        cand.append(p)
        n = p+1
    print(("\n".join(map(str, cand[:k]))))


def __starting_point():
    main()

__starting_point()

t=1
i=1
l=int(input()) 
while l:
  if t<i/sum(map(int,list(str(i)))):
    i+=9*t
    t*=10
  else:
    print(i)
    i+=t
    l-=1

def f(n):
    s=str(n)
    return sum([int(s[i]) for i in range(len(s))])

sunuke=[]
for i in range(16):
    for j in range(1,500):
        sunuke.append(j*(10**i)-1)

sunuke=list(set(sunuke))
sunuke.sort()
sunuke.pop(0)
L=len(sunuke)

tmp1,tmp2=sunuke[L-1],f(sunuke[L-1])
ans=[sunuke[L-1]]
for i in range(len(sunuke)-2,-1,-1):
    x=sunuke[i]
    if x*tmp2<=tmp1*f(x):
        ans.append(x)
        tmp1,tmp2=x,f(x)

ans.sort()

    

for i in range(int(input())):
    print(ans[i])

def R(x):
    return x / sum(map(int, str(x)))
K = int(input())
D = 0
l = 0
for i in range(K):
    D += 10**l
    print(D)
    if 10**l < R(D+10**l):
        l += 1

# -*- coding: utf-8 -*-

"""
参考：https://nuekodory.github.io/2018/06/24/AtCoder-ABC101-ARC-099-%E3%82%92-Python3-%E3%81%A7%E8%A7%A3%E3%81%8F/
　　　http://xxxasdfghjk999.hatenablog.jp/entry/2018/07/22/162323
　　　http://drken1215.hatenablog.com/entry/2018/06/24/010600
　　　http://phyllo-algo.hatenablog.com/entry/2018/06/24/160442
・事前にいくつかの範囲を調べて、候補の数がabc9999....のあたりだけだと予測しておく。
・候補の値だけに絞って最大値から下がっていく。
"""

K = int(input())

def make_snk(num):
    s = str(num)
    sm = 0
    for c in s:
        sm += int(c)
    return num / sm

snk_list = []
mn = float('inf')
suff = '999999999999'
# 後ろに付ける9の数を減らして、10^15-1から10099までを作る
for i in range(11):
    # 999～100までループ
    for j in range(999, 99, -1):
        j = int(str(j) + suff)
        num = make_snk(j)
        if num <= mn:
            snk_list.append(j)
            mn = num
    suff = suff[:-1]
# 9999以下は普通に全部やる(大した大きさじゃないので)
for i in range(9999, 0, -1):
    num = make_snk(i)
    if num <= mn:
        snk_list.append(i)
        mn = num
snk_list.reverse()
for i in range(K):
    print((snk_list[i]))


serch_table = []

for i in range(100):
    for j in range(1,1000):
        x = str(j) + '9'*i
        x = int(x)
        serch_table.append(x)
#print(serch_table)

L = []
for i in serch_table:
    l = [x for x in str(i)]
    x = sum(map(int,l))
    l = [i/x,i]
    L.append(l)
L= sorted(L)
M = []
tmp = -1
for i in L:
    if tmp < i[1]:
        M.append(i[1])
        tmp = i[1]
#print(M,len(serch_table ))
N = int(input())
for i in range(N):
    print((M[i]))


import math

def s(n):
    ret = 0

    while n > 0:
        ret += n % 10
        n = n // 10
        
    return ret

def snuke(n):
    candidate = []

    for d in range(int(math.log(n, 10)) + 2):
        x = n - (n % 10**d) + (10**d - 1)
        candidate.append(x)
    
    min_value = candidate[0] / s(candidate[0])
    ans = candidate[0]
    for c in candidate[1:]:
        tmp = c / s(c)
        if tmp < min_value:
            min_value = tmp
            ans = c
            
    return ans

K = int(input())

N = 0
for i in range(K):
    N = snuke(N + 1)
    print(N)


k = int(input())

def func(a):
    s = 0
    for i in str(a):
        s += int(i)
    return a/s

candidate_lst = []
for i in range(18):
    for j in range(1, 150):
         candidate_lst.append(int(str(j) + '9' * i))
candidate_lst = sorted(list(set(candidate_lst)))

count = 0
index = -1
snuke = 1
while count < k:
    min_snuke = 10**100
    for m, i in enumerate(candidate_lst[index+1:]):
        if i > 100*snuke:
            break
        po_snuke = func(i)
        if min_snuke > po_snuke:
            min_snuke = po_snuke
            next_snuke = i
            next_index = m
    print(next_snuke)
    snuke = next_snuke
    index = index + next_index + 1
    count += 1          

k = int(input())

def digit_sum(s):
    return sum(map(int, list(s)))

def func1(s):
    return int(s)/digit_sum(s)

def func2(n):
    n = str(n)
    fm, fa = float("inf"), -1
    for i in range(len(n)):
        s = n[:i+1] + "9"*(len(n)-i-1)
        if fm > func1(s):
            fm = func1(s)
            fa = int(s)
    return fa

n = 1
for _ in range(k):
    print(n)
    n = func2(n+1)




import sys 

K = int(input())

if K <= 0:
    return

step = 1 
snuke = 1 

while K > 0:
    if step < snuke/sum(map(int, str(snuke))):
        snuke += 9 * step
        step *= 10
    else:
        print(snuke)
        snuke += step
        K -= 1

def S(i):
    ans = 0
    while i // 10 > 0:
        ans += i % 10
        i //= 10
    ans += i
    return ans

K = int(input())
Ans, count, N = [], 0, 1
while count < K:
    N2, Nd = N, 1
    while N2//10 > 0:
        Nd += 1
        N2 //= 10
    minX, X = N/S(N), N
    for i in range(Nd+2):
        x = (N//10**(i+1) + 1) * 10**(i+1) -1
        if minX > x/S(x):
            minX, X = x/S(x), x
    Ans.append((minX, X))
    count += 1
    N = X+1

for i in range(K):
    print(Ans[i][1])

k=int(input())
A=[]
for i in range(1,9):
    A.append([i,1])
now=0
for i in range(15):
    now+=9*10**i
    for j in range(1000):
        c=now+j*10**(i+1)
        S=str(c)
        cnt=0
        for s in S:
            cnt+=int(s)
        A.append([c,c/cnt])
A=list(reversed(sorted(A)))
now=0
m=A[0][1]
Ans=[]
for a in A:
    if a[0]==now:
        continue
    else:
        now=a[0]
        if a[1]<=m:
            Ans.append(now)
            m=a[1]
Ans=list(reversed(Ans))
for i in range(k):
    print(Ans[i])

# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations

sys.setrecursionlimit(10000)


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


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


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


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


def read_str():
    return input()


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


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


def mt(f):
    import time

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

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

    return wrap


def S(n):
    s = 0
    while n != 0:
        s += n % 10
        n //= 10
    return s

# @mt
def slv(K):
    ans = [(i, i/S(i)) for i in range(1, 10)]
    for i in range(16):
        a = i
        if a > 4:
            a = 4
        for j in range(1, 10**a):
            b = (10**(i-a+1))*j + (10**(i-a+1)-1)
            if b < 10**(i-1):
                continue
            s = S(b)
            
            while ans[-1][1] > b/s or ans[-1][0] == b:
                (ans.pop())
            ans.append((b, b/s))
            # print(ans[-1])
    # error_print(len(ans))
    # for r in ans:
    #     error_print(r)
    error_print(len(ans))
    
    return '\n'.join(map(str, map(lambda x: x[0], ans[:K])))


def main():
    K = read_int()
    print(slv(K))

def __starting_point():
    main()

__starting_point()

def sunuke_sum(arg):
    sum_digit = 0
    for char in arg:
        sum_digit += int(char)
    return sum_digit


input_num = int(input())

sunuke_dict = {}

min_sunuke_div = 10 ** 20
for d in reversed(range(1, 16)):
    for n in reversed(range(10, 1000)):
        i = n * (10 ** d) + (10 ** d - 1)
        sunuke_div = i / sunuke_sum(str(i))
        sunuke_dict[i] = sunuke_div

for i in reversed(range(1, 110)):
    sunuke_div = i / sunuke_sum(str(i))
    sunuke_dict[i] = sunuke_div

sunuke_sorted = sorted(sunuke_dict.items())
sunuke_list = []

for value, div_value in reversed(sunuke_sorted):
    if min_sunuke_div >= div_value:
        sunuke_list.append(value)
        min_sunuke_div = div_value

sunuke_list.reverse()

for i in range(0, input_num):
    print(str(sunuke_list[i]))

k = int(input())

def snuke(n):
    s = sum(map(int, str(n)))
    return n / s

digit = 0
ans = 1
for _ in range(k):
    print(ans)
    if snuke(ans + 10 ** digit) > snuke(ans + 10 ** (digit + 1)):
        digit += 1
    ans += 10 ** digit


from math import log10
def nsn(N):
    K = sum( list( map( int, list( str(N)))))
    return N/K

def snuke(N):
    k = int( log10(N))+1
    s = N
    now = nsn(N)
    for d in range(k+1):
        x = (10**(d+1))*(N//(10**(d+1)) + 1) - 1
        y = nsn(x)
        if y < now:
            s = x
            now = y
    return s

K = int( input())
ans = 1
print((1))
for i in range(K-1):
    ans = snuke( ans + 1)
    print(ans)



from math import log10
def nsn(N):
    K = sum( list( map( int, list( str(N)))))
    return N/K

def snuke(N):
    k = int( log10(N))+1
    s = N
    now = nsn(N)
    for d in range(k+1):
        x = (10**(d+1))*(N//(10**(d+1)) + 1) - 1
        y = nsn(x)
        if y < now:
            s = x
            now = y
    return s

K = int( input())
ans = 1
print((1))
for i in range(K-1):
    ans = snuke( ans + 1)
    print(ans)



import sys
input = sys.stdin.readline


def s(n):
    return sum(map(int, list(str(n))))


def f(x):
    nines = max(0, len(str(x)) - 3)
    base = 10**nines - 1
    d = 10**nines
    snuke = x
    ratio = x / s(x)
    candidate = base + (x-base+d-1) // d * d
    for _ in range(150):
        new_ratio = candidate / s(candidate)
        if new_ratio < ratio:
            snuke = candidate
            ratio = new_ratio
        candidate += d
    return snuke


def main():
    k = int(input())
    snuke = 0
    for _ in range(k):
        snuke = f(snuke+1)
        print(snuke)


def __starting_point():
    main()
__starting_point()

K = int(input())

def calc_sunuke(num):
    st = str(num)
    s_num = 0
    for c in st:
        s_num += int(c)
    return num / s_num

def search_sunuke(num):
    num_sunuke = calc_sunuke(num)
    if num >= 100:
        digits = len(str(num))
        if digits < 12:
            for i in range(count + 10**(digits-2), 10**digits, 10**(digits-2)):
                if num_sunuke > calc_sunuke(i):
                    return False
            return True
        else:
            for i in range(count + 10**(digits-3), 10**digits, 10**(digits-3)):
                if num_sunuke > calc_sunuke(i):
                    return False
            return True
    else:
        for i in range(count+1, 100):
            if num_sunuke > calc_sunuke(i):
                return False
        return True



count = 1
sunuke_num = 0
while sunuke_num != K:
    if search_sunuke(count):
        print(count)
        sunuke_num += 1
    if count < 99:
        count += 1
    else:
        count_str = str(count)
        digits = len(count_str)
        r_count = count
        if digits < 12:
            for c in count_str:
                if c != '9':
                    count += 10**(digits - 2)
                    break
            if r_count == count:
                count += 10**(digits - 1)
        else:
            for c in count_str:
                if c != '9':
                    count += 10**(digits - 3)
                    break
            if r_count == count:
                count += 10**(digits - 2)
        



def sum_digit(n):
    n_str = str(n)
    ans = 0
    for dig in n_str:
        ans += int(dig)
    return ans

def snuke(n):
    return n / sum_digit(n)

K = int(input())

ans = 1
print(ans)
for i in range(K - 1):
    s = len(str(ans))
    x = snuke(ans)
    L = [[ans + 10 ** k, snuke(ans + 10 ** k)] for k in range(s+1)]
    L.sort(key = lambda x: x[1])
    ans = L[0][0]
    print(ans)


def s(n):
  return n / sum(map(int,str(n)))

k = int(input())

x = 1
e = 0
i = 0

while i < k:
  
  tmp = (x + 1) * 10 ** e - 1
  nxt = (x + 2) * 10 ** e - 1
  
  if s(tmp) <= s(nxt):
    print(tmp)
    x += 1
    i += 1
  else:
    e += 1
    x = (x + 1)//10

k=int(input())
ans=[]
for i in range(1,10): #1桁の数
  ans.append(str(i))
  
for i in range(1,10): #2桁の数
  ans.append(str(i)+'9')
  
for i in range(1,10): #3桁の数
  ans.append(str(i)+'99')
  
for i in range(10): #4桁の数
  ans.append('1'+str(i)+'99')
for i in range(2,10): #4桁の数
  ans.append(str(i)+'999')
  
for i in range(1,3): #5桁の数
  for j in range(10):
    ans.append(str(i)+str(j)+'999')
for i in range(3,10): #5桁の数
  ans.append(str(i)+'9999')
  
for i in range(1,4): #6桁の数
  for j in range(10):
    ans.append(str(i)+str(j)+'9999')
for i in range(4,10): #6桁の数
  ans.append(str(i)+'99999')
  
for i in range(1,5): #7桁の数
  for j in range(10):
    ans.append(str(i)+str(j)+'99999')
for i in range(5,10): #7桁の数
  ans.append(str(i)+'999999')

for i in range(1,6): #8桁の数
  for j in range(10):
    ans.append(str(i)+str(j)+'999999')
for i in range(6,10): #8桁の数
  ans.append(str(i)+'9999999')
  
for i in range(1,7): #9桁の数
  for j in range(10):
    ans.append(str(i)+str(j)+'9999999')
for i in range(7,10): #9桁の数
  ans.append(str(i)+'99999999')

for i in range(1,8): #10桁の数
  for j in range(10):
    ans.append(str(i)+str(j)+'99999999')
for i in range(8,10): #10桁の数
  ans.append(str(i)+'999999999')

for i in range(1,9): #11桁の数
  for j in range(10):
    ans.append(str(i)+str(j)+'999999999')
for i in range(9,10): #11桁の数
  ans.append(str(i)+'9999999999')
  
for i in range(1,10): #12桁の数
  for j in range(10):
    ans.append(str(i)+str(j)+'9999999999')
for i in range(10,10): #12桁の数
  ans.append(str(i)+'99999999999')

for i in range(1,10): #13桁の数
  for j in range(10):
    ans.append(str(i)+str(j)+'99999999999')
for i in range(10,10): #13桁の数
  ans.append(str(i)+'999999999999')
  
for i in range(1,10): #14桁の数
  for j in range(10):
    ans.append(str(i)+str(j)+'999999999999')
for i in range(10,10): #14桁の数
  ans.append(str(i)+'9999999999999')

for i in range(10): #15桁の数
  ans.append('10'+str(i)+'999999999999')
for i in range(1,10): #15桁の数
  ans.append('1'+str(i)+'9999999999999')
for i in range(2,10): #15桁の数
  for j in range(10):
    ans.append(str(i)+str(j)+'9999999999999')
  
for val in ans[:k]:
  print(val)

K = int(input())

def minSunuke(n) :  # n以上の n/S(n) の最小値
    sumDigit = sum(map(int, list(str(n))))
    return n / sumDigit

digit = 0
now = 1

for i in range(K) :
    print(now)
    if minSunuke(now + 10**digit) > minSunuke(now + 10**(digit + 1)) :
        digit += 1
    now += 10**digit


def snk_cal(i):
    snk = i
    i = str(i)
    q = 0
    for j in range(len(i)):
        q += int(i[j])
    snk /= q
    return snk

K = int(input())
if K <= 9:
    for i in range(K):
        print((i+1))
else:
    for i in range(9):
        print((i+1))
    K -= 9
    snk = 9
    while K > 0:
        res = snk+1
        d = len(str(res))
        l = []
        for i in range(d):
            n = int(str(res)[:-i-1]+'9'*(i+1))
            l.append(snk_cal(n))
        i = l.index(min(l))
        snk = int(str(res)[:-i-1]+'9'*(i+1))
        print(snk)
        K -= 1


import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log10
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

K = INT()

def S(n): # 和,nは文字列
	return sum([int(x) for x in list(n)])

def f(N):
	sunuke = []
	for d in range(-1, int(log10(N)+1)):
		sunuke.append(10**(d+1) * (N//(10**(d+1))+1)-1)
	sunuke2 = [x/S(str(x)) for x in sunuke]
	return sunuke[sunuke2.index(min(sunuke2))]

N = 1
for _ in range(K):
	print(N)
	N = f(N+1)


k = int(input())
candili = []
for i in range(1, 1000):
    candili.append(i)

tmpli = []
for i in candili:
    for j in range(1, 15):
        tmpli.append(int(str(i) + "9" * j))
tmpli = list(set(tmpli))

tmp2li = []
for i in tmpli:
    if i <= 10 ** 15:
        tmp2li.append(i)
candili += tmp2li
candili = list(set(candili))
candili.sort()

def S(n):
    return sum(int(i) for i in str(n))

conli = []

for i in candili:
    conli.append(i/S(i))

ansli = []
for i in range(len(conli)):
    for j in range(i, len(conli)):
        if conli[i] > conli[j]:
            break
    else:
        ansli.append(candili[i])

for i in range(k):
    print(ansli[i])

K=int(input())
D={}
for i in range(1,10**4):
    for j in range(12):
        Sunuke=str(i)+("9"*j)
        if len(Sunuke)<=15 and Sunuke not in D:
            S=0
            for k in range(len(Sunuke)):
                S+=int(Sunuke[k])
            D[int(Sunuke)]=S
D=list(D.items())
D.sort()
#print(D[:10])
import bisect

d=[10**16 for i in range(len(D))]
d[0]=0
ans=[0 for i in range(len(D))]
for i in range(len(D)):
    ans[bisect.bisect_right(d,D[i][0]/D[i][1])]=D[i][0]
    d[bisect.bisect_right(d,D[i][0]/D[i][1])]=D[i][0]/D[i][1]
    
#print(ans[:50])
ANS=[]
MAX=0
for i in range(len(ans)):
    if ans[i]>MAX:
        ANS.append(ans[i])
        MAX=ans[i]
#print(ANS[:100])
for i in range(K):
    print((ANS[i]))
#print(d[:10])


K = int(input())

def S(n):
    return sum(int(c) for c in str(n))
d9 = 0
cnt = 0
upper = 1
while cnt < K:
    n = int(str(upper) + ('9' * d9))
    if n <= S(n) * (10 ** d9):
        print(n)
        cnt += 1
        upper += 1
    else:
        d9 += 1
        upper //= 10


#!/usr/bin/env python3
from fractions import Fraction
import sys


def g():
    i = 1
    while True:
        si = str(i)
        ni = min({
            int(si[:j] + "9" * (len(si) - j))
            for j in range(len(si) + 1)
        }, key=lambda a: (Fraction(a, sum(int(x) for x in str(a))), a))
        yield ni
        i = ni + 1


def solve(K: int):
    it = g()
    for i in range(K):
        print((next(it)))


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    K = int(next(tokens))  # type: int
    solve(K)


def __starting_point():
    main()

__starting_point()

# -*- coding: utf-8 -*-
k = int(input())


def snuke(n):
    s = 0
    for _ in str(n):
        s += int(_)
    return n / s


n = 1
d = 0
for _ in range(k):
    print(n)
    if snuke(n + 10**d) > snuke(n + 10**(d + 1)):
        d += 1
    n += 10**d


def main():
    s=set()
    for digit in range(16):
        for i in range(1,1000):
            c=i*10**digit+int('9'*digit or 0)
            if c<10**15:
                s.add(c)
    c=sorted(s)
    for i,n in enumerate(c):
        sn=n/sum(map(int,str(n)))
        for m in c[i+1:i+100]:
            sm=m/sum(map(int,str(m)))
            if sm<sn:
                s.remove(n)
                break
    print(*sorted(s)[:int(input())],sep='\n')
main()

K = int(input())

def snuke(n):
  n_list = [int(i) for i in list(str(n))]
  return n / sum(n_list)

ans = 1
digit = 0

while K > 0:
  print(ans)
  if snuke(ans + 10**digit) > snuke(ans + 10**(digit+1)):
    digit += 1
  ans += 10**digit
  K -= 1


K = int(input())

def sunuke(n) :
    sumN = sum(map(int, list(str(n))))
    return n / sumN

digit = 0
now = 1

for i in range(K) :
    print(now)
    if sunuke(now + 10**digit) > sunuke(now + 10**(digit + 1)) :
        digit += 1
    now += 10**digit

K = int(input())
 
def f(n):
    return n / sum([int(s) for s in str(n)])

ans = [1]
for k in range(K - 1):
    min_f_val, next_snuke = float('inf'), None
    n = str(ans[-1] + 1)
    for i in range(len(n)):
        for x in range(int(n[i]), 10):
            X = n[:i] + str(x) + '9' * (len(n) - i - 1)
            f_val = f(int(X))
            if f_val < min_f_val:
                next_snuke = int(X)
                min_f_val = f_val
    ans.append(next_snuke)
print(*ans, sep='\n')

l=int(input())

def f(n):
	return n/sum(list(map(int,list(str(n)))))

a=[]
for i in range(1,16):
	if i<=3:
		for j in range(1,10):
			a.append((j+1)*(10**(i-1))-1)
	elif i<=12:
		for j in range(1,10):
			b=[j*(10**(i-1))+(k+1)*(10**(i-2))-1 for k in range(10)]
			for k in range(9)[::-1]:
				if f(b[k])>f(b[k+1]):
					b.pop(k)
			a+=b
	else:
		for j in range(1,10):
			b=[j*(10**(i-1))+(k+1)*(10**(i-3))-1 for k in range(100)]
			for k in range(99)[::-1]:
				if f(b[k])>f(b[k+1]):
					b.pop(k)
			a+=b

for i in range(l):
	print((a[i]))


k = int(input())

def s(n):
    r = 0
    while n > 0:
        r += n % 10
        n = n // 10
    return r
    

def find_next(n):
    d = 0
    m = n // 10
    sm = s(m)
    r = 0
    grad = 10 * m + 1 - sm - 9 * d - 1/(10**d)
    while grad > 0:
        r += 9 * 10**d
        d += 1
        sm -= m % 10
        m = m // 10
        grad = 10 * m + 1 - sm - 9 * d - 1/(10**d)
    r += (n // 10**d) * 10**d
    return r

for i in range(1, min(k, 9) + 1):
    print(i)
    
k -= min(k, 9)
p = 10

for i in range(0, k):
    p = find_next(p)
    print(p)
    p += 1

def S(n):
    k=list(str(n))
    import functools
    return functools.reduce(lambda x,y:x+y,[int(i) for i in k])
k=int(input())
def T(n):
    return n/S(n)
def f(N):
    len_N=len(str(N))
    A=[10**len_N+10**i-1 for i in range(len_N)]
    B=[T(i) for i in A]
    ans1=A[B.index(min(B))]
    i=0
    while True:
        I=10**(len_N-1)+10**i-1
        J=10**(len_N-1)+10**(i+1)-1
        if T(J)<T(I):
            i+=1
        else:
            break
    C=[((N+1)//(10**i))*10**i+j*10**i-1 for j in range(1,11)]
    D=[T(i) for i in C]
    ans2=C[D.index(min(D))]
    if T(ans1)<T(ans2):
        return(ans1)
    else:
        return(ans2)
K=[]
N=1
while len(K)<k:
    K.append(N)
    N=f(N)
for i in range(k):
    print((K[i]))


#D問題
K=int(input())
keta=1
now=1
count=0

def sunuke(n):
    a=0
    for i in str(n):
        a+=int(i)
    return(n/a)

while count < K:
    if sunuke(now) <= sunuke(now+keta):
        print(now)
        now+=keta
        count+=1
    else:
        now+=9*keta
        keta*=10



import math
# import datetime

def s(n):
	sum = 0
	for c in str(n):
		sum += int(c)
	return sum

k = int(input())
found=0

def next_sunuke(n, s_n, s_n_div):

	nonlocal found

	if n == 1:
		return

	log_n = int(math.log(n,10))
	m = n - 10 ** int(log_n // 1.25)
	# m = n - 1

	while m >= 1:
		s_m = s(m)
		s_mplus1 = s(m + 1)

		# if (s_m < s_mplus1 or (s_n - s_m != 1 and s_n - s_m != -8)) and m > 9:
		if (s_m < s_mplus1) and m > 9:
			m -= 10 ** int(log_n // 1.25)
			continue

		# print("check: " + str(m))

		s_m_div = m / s(m)

		if s_m_div <= s_n_div:
			next_sunuke(m, s_m, s_m_div)
			if found >= k:
				return

			found += 1
			# print("{0:d}".format(m), "{0:+d}".format(n-m), "{0:d}".format(s_m), s_m_div)
			print(m)
			break
		# else:
		# 	log_m = int(math.log(m,10))
		# 	if (m + 1) / (10 ** (log_m - 1)) == 19:

		# 		print ("skip: " + str(m) + " to " + str(10 ** log_m - 1))

		# 		m = 10 ** log_m - 1
		# 		s_mplus1 = s(m+1)
		# 		continue

		m -= 10 ** int(log_n // 1.25)


# 適当な大きいスヌケ数
current_sunuke = 999999999999999
s_current_sunuke = s(current_sunuke)
s_current_sunuke_div = current_sunuke / s_current_sunuke

# start = datetime.datetime.now()
next_sunuke(current_sunuke, s_current_sunuke, s_current_sunuke_div)
if found < k:
	print(current_sunuke)
# end = datetime.datetime.now()
# print(str(end-start))

# sunukes=[]

# n = current_sunuke - 1

# while(n >= 1):
# 	s_n = n / s(n)
# 	if s_n <= current_sunuke_n:
# 		#sunukes.insert(0,n)
# 		sunukes.append(n)
# 		current_sunuke = n
# 		current_sunuke_n = s_n
# 	n -= 1

# for n in sunukes:
# 	print (n)


K = int(input())

def snuke(n):
  sum_num = sum(map(int, list(str(n))))
  return n / sum_num

ans = 1
digit = 0
while K > 0:
  print(ans)
  if snuke(ans + 10**digit) > snuke(ans + 10**(digit+1)):
    digit += 1
  ans += 10**digit
  K -= 1

def f(N):
    l = 0
    NN = N
    while True:
        l += 1
        NN //= 10
        if NN < 10:
            break
    m = N / sum(map(int,list(str(N))))
    num = -1
    for d in range(0,l+2):
        x = (10 ** (d+1)) * int(N/(10**(d+1))+1) - 1
        sx = sum(map(int,list(str(x))))
        value = x/sx
        if value < m:
            m = value
            num = d
    if num == -1:
        return N
    else:
        return (10 ** (num+1)) * int(N/(10**(num+1))+1) - 1

K = int(input())

N = 1
ans = [1]

while len(ans) < K:
    N = f(N+1)
    ans.append(N)

for i in ans:
    print(i)


import sys
stdin = sys.stdin

sys.setrecursionlimit(10**5)

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

def ds(n:int):
    return sum([int(i) for i in str(n)])

def snuke(n:int):
    return n/ds(n)

def cands(n:int):
    ret = []
    nl = len(str(n))
    for i in range(nl):
        ret.append(str(n)[:nl-i-1] + "9"*(i+1))
        
    return ret

k = ni()

# 1から9まで
ans = [i for i in range(1,10)]

# 次の候補
cur = 10
while len(ans) < k:
    cand = cands(cur)
    temp = 10**18
    nex = -1
    for c in cand:
        if snuke(int(c)) <= temp:
            temp = snuke(int(c))
            nex = int(c)
            
    ans.append(nex)
    cur = nex+1
    
for ai in ans[:k]:
    print(ai)

def s(n):
  return n / sum(map(int, str(n)))
k = int(input())
p = 1
e = 0
i = 0
while i < k:
  n = (p + 1) * 10**e - 1
  nxt = (p + 2) * 10**e - 1
  if s(n) <= s(nxt):
    print(n)
    p += 1
    i += 1
  else:
    e += 1
    p = (p + 1) // 10


def sk(k):
    tk = k
    ret = 0
    while tk!=0:
        ret+=tk%10
        tk//=10
    return ret
an = []
for i in range(1,100):
    tp = i/sk(i)
    if len(an)==0:an.append((i,tp))
    else:
        ls=an[-1]
        if ls[1]>tp:an[-1]=(i,tp)
        else:an.append((i,tp))
for j in range(15):
    for i in range(100,1000):
        ns=str(i)+''.join(['9']*j)
        nm=int(ns)
        tp=nm/sk(nm)
        if an[-1][1] > tp:
            while an[-1][1]>tp:
                an.pop()
        an.append((nm,tp))
for i in range(int(input())):print(an[i][0])

K = int(input())


def dsum(n):
    return sum(list(map(int, str(n))))


def g(n):
    return n / dsum(n)

j = 1
order = 1
for i in range(K):
    print(j)
    if g(j + 10 ** (order - 1)) > g(j + 10 ** order):
        order += 1
    j += 10 ** (order - 1)


K = int(input())

#すぬけ数候補
# [n, S(n)/n] で覚える
snukePairs = []

for i in range(1, 16):
    top = 1  #上位何桁を1-9の走査範囲とするか
    if i >= 12:
        top = 3
    elif i >= 4:
        top = 2
    p = pow(10, i - top)
    fill9 = p - 1
    top_num = pow(10, max(top, 1)) #たかが1000。全部回す
    check_index = len(snukePairs)
    for j in range(pow(10, top - 1), top_num):
        num = j * p + fill9
        nn = num
        s = 0
        #各桁合計、 S(n) / n 計算
        while nn > 0:
            s += nn % 10
            nn = nn // 10
        val = num / s

        #既存のもののうち、valより小さいものを除外
        idx = len(snukePairs) - 1
        while idx >= 0:
            if snukePairs[idx][1] > val:
                del snukePairs[idx]
            idx -= 1
        snukePairs.append([num, val])

for i in range(0, K):
    print((snukePairs[i][0]))



k = int(input())
keta = 1
ima = 1
def sunuke(n) :
    a = 0
    for i in str(n) :
        a += int(i)
    return(n/a)
count = 0
while count < k :
    if sunuke(ima) <= sunuke(ima+keta) :
        print(ima)
        ima += keta
        count += 1
    else :
        ima += 9*keta
        keta *= 10

K=int(input())

def NS(N):
  NS=0
  while(N>0):
    NS+=N%10
    N//=10
  return NS

answer,diff=0,1
for i in range(K):
  answer+=diff
  print(answer)
  
  if diff<(answer+diff)/NS(answer+diff):
    diff*=10

import math


def next_sunuke(N):
    D = math.ceil(math.log(N, 10) + 1)
    z = str(N)
    zx = [int(z[:1]) for z in z]
    Z = N / sum(zx)
    ret_val = N
    ret_vals = [ret_val]
    for d in range(0, D):
        x = ((10 ** (d + 1)) * math.floor((N / (10 ** (d + 1))) + 1)) - 1
        w = str(x)
        sx = [int(w[:1]) for w in w]
        y = x / sum(sx)
        if y == Z:
            Z = y
            ret_vals.append(x)
        elif y < Z:
            Z = y
            ret_vals = []
            ret_vals.append(x)
    return min(ret_vals)


K = int(input())
n = 1
for i in range(1, K + 1):
    print((next_sunuke(n)))
    n = next_sunuke(n) + 1


import math
# import datetime

def s(n):
	sum = 0
	for c in str(n):
		sum += int(c)
	return sum

k = int(input())
found=0

def next_sunuke(n, s_n, s_n_div):

	nonlocal found

	if n == 1:
		return

	log_n = int(math.log(n,10))
	m = n - 10 ** int(log_n // 1.25)

	while m >= 1:
		s_m = s(m)
		s_mplus1 = s(m + 1)

		if (s_m < s_mplus1 or (s_n - s_m != 1 and s_n - s_m != -8 and s_n - s_m != -17)) and m > 9:
			m -= 10 ** int(log_n // 1.25)
			continue

		# print("check: " + str(m))

		s_m_div = m / s(m)

		if s_m_div <= s_n_div:
			next_sunuke(m, s_m, s_m_div)
			if found >= k:
				return

			found += 1
			# print("{0:d}".format(m), "{0:+d}".format(n-m), "{0:d}".format(s_m), s_m_div)
			print(m)
			break


		m -= 10 ** int(log_n // 1.25)


# 適当な大きいスヌケ数
current_sunuke = 999999999999999
s_current_sunuke = s(current_sunuke)
s_current_sunuke_div = current_sunuke / s_current_sunuke

# start = datetime.datetime.now()
next_sunuke(current_sunuke, s_current_sunuke, s_current_sunuke_div)
if found < k:
	print(current_sunuke)
# end = datetime.datetime.now()
# print(str(end-start))


K =int(input())
a = 0
b = 1

for k in range(K):
  a+=b
  print(a)
  
  if b<(a+b)/sum(map(int,str(a+b))):
    b*=10

k = int(input())

# 関数S(n)
def S(num):
  s = sum(map(int,list(str(num))))
  return num/s

#1~9と 〇9-> 〇99 -> 〇999 を出力
ten = 0
now = 1
# k回ループ
for _ in range(k) :
  print(now)
  # 桁が変わる時にten+=1する
  if S(now + 10**ten) > S(now + 10**(ten + 1)) :
    #print(now,S(now + 10**ten), S(now + 10**(ten + 1)))
    ten += 1
  now += 10**ten
    
    
  
  
  
  




k = int(input())

def f(num):
  return num / sum(map(int, list(str(num))))

order = 0
sunuke = 1
for i in range(k):
  print(sunuke)
  sunuke += 10**order
  if f(sunuke + 10**(order+1)) < f(sunuke + 10**order):
    order += 1

k = int(input())

l = []
for i in range(17):
    ten = 10**i
    for j in range(1,1000):
        a = ten
        b = j
        n = a*b-1
        if n == 0:
            continue
        s = sum(map(int,str(n)))
        l.append([n/s,n])
l.sort()
now = 0
count = 0
i = 0
while count < k:
    if l[i][1] > now:
        now = l[i][1]
        count += 1
        print((l[i][1]))
    i += 1


def sk(k):
  tk = k
  ret = 0
  while tk!=0:
    ret+=tk%10
    tk//=10
  return ret

ans = []
for i in range(1,100):
  tmp = i/sk(i)
  if len(ans)==0:
    ans.append((i,tmp))
  else:
    l=ans[-1]
    if l[1]>tmp:
      ans[-1]=(i,tmp)
    else:
      ans.append((i,tmp))

for j in range(15):
  for i in range(100,1000):
    n=int(str(i)+''.join(['9']*j))
    tmp=n/sk(n)
    if ans[-1][1] > tmp:
      while ans[-1][1]>tmp:
        ans.pop()
    ans.append((n,tmp))

for i in range(int(input())):
  print(ans[i][0])

def S(i):
    ans = 0
    while i // 10 > 0:
        ans += i % 10
        i //= 10
    ans += i
    return ans

K = int(input())
count, N = 0, 1
while count < K:
    N2, Nd = N, 1
    while N2//10 > 0:
        Nd += 1
        N2 //= 10
    minX, X = N/S(N), N
    for i in range(Nd+2):
        x = (N//10**(i+1) + 1) * 10**(i+1) -1
        if minX > x/S(x):
            minX, X = x/S(x), x
    print(X)
    count += 1
    N = X+1

def f(x):
    return x / sum(map(int, str(x)))
 
K = int(input()) 
x, y = 1, 1
 
for i in range(K):
    print(x)
    if f(x + y) > f(x + y * 10):
        y *= 10
    x += y

K = int(input())
 
res = [(0, 0)]
mm = 0
cands = []
for i in range(1, 1000):
  v = i
  for j in range(16):
    cands.append(v)
    v = 10 * v + 9

cands = list(sorted(set(cands)))

for x in cands:
  i = sum(ord(c) - ord('0') for c in str(x))
  while x / i < res[-1][0]:
    res = res[:-1]
  res.append((x / i, x))
 
for i in range(1, K + 1):
  print(res[i][1])

K = int(input())
n = 1
dn = 1
c = 0
while c < K:
    print(n)
    c += 1
    if (n + dn) > sum(map(int, str(n + dn))) * dn:
        dn *= 10
    n += dn


K = int(input())

def nd(n):
    ans = 0
    nn = n
    while(nn > 0):
        ans += nn%10
        nn //= 10
    return ans/n

def k_next(k):
  d = 1
  c_max = 0
  ans = k
  while(d < k*10):
    cand = (k//d+1)*d+(k%d)
    if nd(cand) >= c_max:
      c_max = nd(cand)
      ans = cand
    d *= 10
  return ans

k = 1
for i in range(K):
  print(k)
  k = k_next(k)




#!/usr/bin/env python
# coding: utf-8

def ri():
    return int(input())

def rl():
    return list(input().split())

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

def calc(n):
    s = sum(map(int, str(n)))
    return n / s

def main():
    k = ri()
    cand = list(range(1, 10))
    last = 9
    for n in range(1, 15):
        pow10n = pow(10, n)
        for d in range(1, 10):
            lim = (d+1)*pow10n
            e = 0
            while True:
                e1 = d*pow10n+e*(last+1)+last
                if e1 >= lim:
                    break
                e2 = e1 + (last+1)
                if calc(e1) > calc(e2):
                    last = last*10+9
                    e = 0
                    continue
                cand.append(e1)
                e += 1
    cand = sorted(list(set(cand)))
    print(("\n".join(map(str, cand[:k]))))


def __starting_point():
    main()

"""
1 1.0
2 1.0
3 1.0
4 1.0
5 1.0
6 1.0
7 1.0
8 1.0
9 1.0
19 1.9
29 2.6363636363636362
39 3.25
49 3.769230769230769
59 4.214285714285714
69 4.6
79 4.9375
89 5.235294117647059
99 5.5
199 10.473684210526315
299 14.95
399 19.0
499 22.681818181818183
599 26.043478260869566
699 29.125
799 31.96
899 34.57692307692308
999 37.0
1099 57.8421052631579
1199 59.95
1299 61.857142857142854
1399 63.59090909090909
1499 65.17391304347827
1599 66.625
1699 67.96
1799 69.1923076923077
1899 70.33333333333333
1999 71.39285714285714
2999 103.41379310344827
3999 133.3
4999 161.25806451612902
5999 187.46875
6999 212.0909090909091
7999 235.26470588235293
8999 257.1142857142857
9999 277.75
10999 392.82142857142856
11999 413.7586206896552
12999 433.3
13999 451.5806451612903
14999 468.71875
15999 484.8181818181818
16999 499.97058823529414
17999 514.2571428571429
18999 527.75
19999 540.5135135135135
20999 724.1034482758621
21999 733.3
22999 741.9032258064516
23999 749.96875
24999 757.5454545454545
25999 764.6764705882352
26999 771.4
27999 777.75
28999 783.7567567567568
29999 789.4473684210526
39999 1025.6153846153845
49999 1249.975
59999 1463.3902439024391
69999 1666.642857142857
79999 1860.4418604651162
89999 2045.4318181818182
99999 2222.2
109999 2972.945945945946
119999 3157.8684210526317
129999 3333.3076923076924
139999 3499.975
149999 3658.512195121951
159999 3809.5
169999 3953.4651162790697
179999 4090.8863636363635
189999 4222.2
199999 4347.804347826087
209999 5526.289473684211
219999 5641.0
229999 5749.975
239999 5853.634146341464
249999 5952.357142857143
259999 6046.488372093023
269999 6136.340909090909
279999 6222.2
289999 6304.326086956522
299999 6382.95744680851
309999 7948.692307692308
319999 7999.975
329999 8048.756097560976
339999 8095.214285714285
349999 8139.511627906977
359999 8181.795454545455
369999 8222.2
379999 8260.847826086956
389999 8297.851063829787
399999 8333.3125
499999 10204.061224489797
599999 11999.98
699999 13725.470588235294
799999 15384.596153846154
899999 16981.11320754717
999999 18518.5
"""


__starting_point()

# 下d+1桁目が初めて9でないとする
# [__X__]99999
# [_X++_]99999に勝つ必要がある
# 10^d(X+1)-1 / (S(X) + 9d) <= (10^d(X+2)-1) / (S(X)+9d+1)
# (S(X)+9d+1)/(S(X)+9d) <= (10^d(X+2)-1)/(10^d(X+1)-1)
# 1/(S(X)+9d) <= 10^d / (10^d(X+1)-1) <= 1/X
# X <= S(X)+9d <= 135

def S(n):
  if n < 10:
    return n
  return S(n//10) + n%10
  
li = [] # 候補、とりあえず十分量作る

for d in range(20):
  a = 10**d
  for x in range(200):
    y = (x+1)*a-1
    if y > 0:
      z = S(y)
      li.append((y,z))
    
li = sorted(list(set(li)),reverse=True)

# 右から見ていって、その時点での最小値タイ以下なら採用
answer = []
min_N,min_S = li[0]
for n,s in li[1:]:
  # n/s < min_N/min_S
  if n*min_S <= s*min_N:
    min_N = n
    min_S = s
    answer.append(n)


K = int(input())
answer.sort()
answer = answer[:K]
print(('\n'.join(map(str,answer))))



import numpy as np

def set_power(a, power_array):
    res = 1
    for i in range(len(power_array)):
        power_array[i] = res
        res *= a


def solve(ans, K, arr):
    p = 0
    for d in range(15):
        pow = arr[d]
        x = pow - 1
        for i in range(1, 10):
            if d > 2:
                y = i * pow + arr[d - 1] - 1
                if y <= (9*(d - 1) + 1)*arr[d - 1]:
                    for j in range(0, 9):
                        if d > 9:
                            z = i*pow + j*arr[d - 1] + arr[d - 2] - 1
                            if z <= (9 * (d - 2) + j + 1) * arr[d - 2]:
                                for j2 in range(0, 9):
                                    ans[p] = z + j2 * arr[d - 2]
                                    p += 1
                        ans[p] = y + j * arr[d - 1]
                        p += 1
            ans[p] = i * pow + x
            p += 1
    return p

K = int(input())
ans = np.empty(10000, dtype=np.int64)
power_array = np.empty(16, dtype=np.int64)
set_power(10, power_array)
p = solve(ans, K, power_array)
print(*ans[:K].tolist(), sep='\n')


k = int(input())

def snuke(n):
    def func(a):
        s = 0
        for i in str(a):
            s += int(i)
        return a/s
    
    len_n = len(str(n))
    min_snu = 10 ** 100
    for i in range(len_n):
        snu = str(n)[:len_n-i] + i * '9'
        func_snu = func(int(snu))
        if min_snu > func_snu:
            min_snu = func_snu
            snukee = int(snu)
            
    return snukee

count = 0
n = 1
while count < k:
    next_snuke = snuke(n)
    print(next_snuke)
    n = next_snuke + 1
    count += 1

k=int(input())
def s(n):
    m=str(n)
    l=list(m)
    l=map(int,l)
    return n/sum(l)
p=1
q=0
for i in range(k):
    print(p)
    if s(p+10**q)>s(p+10**(q+1)):
        q+=1
    p+=10**q

K = int(input())

P = [n for n in range(1, 10)]
Q = [n for n in range(1, 10)]
for d in range(20):
    if d < 12:
        for m in range(10, 100):
            P.append(int(str(m)+"9"*d))
            Q.append(m//10+m%10+9*d)
    else:
        for m in range(100, 1000):
            P.append(int(str(m)+"9"*(d-1)))
            Q.append(sum([int(s) for s in str(m)])+9*(d-1))

L = len(P)
c = 0
for i, (p, q) in enumerate(zip(P, Q)):
    ok = True
    for j in range(i+1, L):
        np, nq = P[j], Q[j]
        if np*q < nq*p:
            ok = False
            break
    if ok:
        print(p)
        c += 1
    if c == K:
        break


"""
import matplotlib.pyplot as plt

A = []
B = []
for n in range(-1+10**10, 10**14, 10**10):
    m = sum([int(s) for s in str(n)])
    A.append(n)
    B.append(n/m)


plt.plot(A, B)
plt.show()
"""

def snuke(n) :
    s=sum(map(int,str(n)))
    return n/s

k=int(input())
digit=0
ans=1
for _ in range(k):
    print(ans)
    if snuke(ans+10**digit)>snuke(ans+10**(digit+1)):
        digit+=1
    ans+=10**digit

import sys

def S(n):
  return n / sum(map(int, str(n)))


def f(n):
  d = 0
  C = [n]
  while S(n) > (10**d / 9*(d+1)):
    c = 10**(d+1) * (n // 10**(d+1) + 1) - 1
    C.append(c)
    d += 1
  Smin = float('inf')
  res = 0
  for c in C:
    if S(c) < Smin:
      Smin = S(c)
      res = c  
  return res


def main():
  input = sys.stdin.readline
  K = int(input())
  ans = 1
  for _ in range(K):
    print(ans)
    ans = f(ans+1)


def __starting_point():
  main()
__starting_point()

from collections import deque
k = int(input())

digsum = lambda x: sum(map(int, list(str(x))))
dignorm = lambda x: x/digsum(x)

n = 1
order = 1
while k > 0:
    print(n)
    k -= 1
    if dignorm(n+10**(order-1)) > dignorm(n+10**order):
        order += 1
    n += 10**(order-1)



import math
K=int(input())
k=2
m=0
def D(x):
  s=str(x)
  array=list(map(int,list(s)))
  return sum(array)
N=1
S=1
a=0
print((1))
while k<=K:
  N+=10**a
  S=D(N)
  if a<math.log10(N/S):
    a+=1
    N=(N//10**a+1)*10**a-1
  S=D(N)
  print(N)
  k+=1
    
    


from math import log10, ceil


def S(n: int) -> int:
    """n を十進法で表した時の各桁のあたいの総和
    :param n: 任意の正の整数
    :return: 十進法の各桁の和
    """
    s = 0
    while n > 0:
        s += n % 10
        n //= 10
    return s


def f(N: int) -> int:
    if N < 10:
        return N

    D = ceil(log10(N) + 1)
    x = 10 * (N // 10 + 1) - 1
    for d in range(1, D + 1):
        td = 10 ** (d + 1)
        nx = td * (N // td + 1) - 1

        if nx / S(nx) < x / S(x):
            x = nx
    return x


def __starting_point():
    K = int(input())
    N = 1
    for _ in range(K):
        print(N)
        N = f(N+1)

__starting_point()

import sys
K = int(input())
count = 0
nine = ""

arr = []
arr_sunuke = []
for k in range(14):
    for i in range(10):
        for j in range(10):
            for l in range(10):
                if i == 0 and nine != "":
                    pass
                else:
                    arr.append(int(str(i)+str(j)+str(l)+nine))
                    arr_sunuke.append(i + j + l + k*9)
    nine = nine + str(9)

arr.remove(0)
arr_sunuke.remove(0)
arr_sunuke2 = [arr[i]/arr_sunuke[i] for i in range(len(arr))]

ans = []
tmp = 10**15
for i in range(len(arr)-1, -1, -1):
    if arr_sunuke2[i] <= tmp:
        ans.append(arr[i])
        tmp = arr_sunuke2[i]

ans = ans[::-1]
for i in range(K):
    print(ans[i])

m=float("INF")
sunukes=[]
for i in range(7,-1,-1):
    for j in range(1000,10,-1):
        #print(i,j)
        sunuke=j*(100**i)-1
        s=str(sunuke)
        sn=0
        for k in range(len(s)):
            sn+=int(s[k])
        x=sunuke/sn
        #print(sunuke,x)
        if x<=m :
            m=x
            sunukes.append(sunuke)
for i in range(9,0,-1):
    sunukes.append(i)
sunukes=sunukes[::-1]
k=int(input())
#print(sunukes)
for i in range(k):
    print(sunukes[i])

k = int(input())
n = 1
dif = 1
cnt = 0

while cnt!=k:
  sn = 0
  for ele in str(n):
    sn+=int(ele)

  m = n+dif
  sm = 0
  for ele in str(m):
    sm+=int(ele)
  if (n/sn) <= (m/sm):
    print(n)
    cnt+=1
    n+=dif
  else:
    n-=dif
    dif*=10
    n+=dif

K = int(input())


def ns(n):
    ret, tmp = 0, n

    while tmp > 0:
        tmp, r = divmod(tmp, 10)
        ret += r

    return ret


ans, base = 0, 1
for _ in range(K):
    ans += base
    print(ans)

    if (ans + base) / ns(ans + base) > (ans + 10 * base) / ns(ans + 10 * base):
        base *= 10

K=int(input())
n=1
k=0
x=[]
y=x.append
while(n<=10**15):
    plus=10**k
    if n>=1350*plus:
        n+=9*plus
        k+=1
        plus*=10
    y([n,n/sum(map(int,list(str(n))))])
    n+=plus
x2=[]
y2=x2.append
min_=10**15
for i in range(len(x)-1,-1,-1):
    if x[i][1]<=min_:
        y2(x[i][0])
        min_=x[i][1]
x2=list(reversed(x2))
for i in range(K):
    print(x2[i])

def f(n):
    s=str(n)
    return sum([int(s[i]) for i in range(len(s))])

sunuke=[]
for i in range(16):
    for j in range(1,200):
        sunuke.append(j*(10**i)-1)

sunuke=list(set(sunuke))
sunuke.sort()
sunuke.pop(0)
L=len(sunuke)

tmp1,tmp2=sunuke[L-1],f(sunuke[L-1])
ans=[sunuke[L-1]]
for i in range(len(sunuke)-2,-1,-1):
    x=sunuke[i]
    if x*tmp2<=tmp1*f(x):
        ans.append(x)
        tmp1,tmp2=x,f(x)

ans.sort()

    

for i in range(int(input())):
    print(ans[i])

k = int(input())
sunuke_list = [1,2,3,4,5,6,7,8]
def s(n):
    n_charlist = list(str(n))
    return sum(list(map(int, n_charlist)))
def combine_int(i,n):
    i_charlist = list(str(i))
    n_charlist = ['9'] * n
    ret_charlist = i_charlist + n_charlist
    ret_str = ''.join(ret_charlist)
    return int(ret_str)
for n in range(1,14):
    if n >= 12:
        i = n-2
    else:
        i = n-1
    while((i+1)/(s(i)+9*n) <= (i+2)/(s(i+1)+9*n)):
        sunuke_list.append(combine_int(i,n))
        i += 1
for i in range(k):
    print((sunuke_list[i]))


t = i = 1
k = int(input()) 
while k:
  if t < i / sum(map(int, list(str(i)))):
    i += 9 * t
    t *= 10
  else:
    print(i)
    i += t
    k -= 1

k = int(input())

l = []
for i in range(17):
    ten = 10**i
    for j in range(1,1000):
        a = ten
        b = j
        n = a*b-1
        if n == 0:
            continue
        s = sum(map(int,str(n)))
        l.append([n/s,n])
l.sort()
now = 0
count = 0
i = 0
while count < k:
    if l[i][1] > now:
        now = l[i][1]
        count += 1
        print(l[i][1])
    i += 1

t = i = 1
k = int(input()) 
while k:
  if t < i / sum(map(int, list(str(i)))):
    i += 9 * t
    t *= 10
  else:
    print(i)
    i += t
    k -= 1


K = int(input())


def ns(n):
    ret, tmp = 0, n

    while tmp > 0:
        #        tmp, r = divmod(tmp, 10)
        r = tmp % 10
        tmp //= 10
        ret += r

    return ret


ans, base = 0, 1
for _ in range(K):
    ans += base
    print(ans)

    if (ans + base) / ns(ans + base) > (ans + 10 * base) / ns(ans + 10 * base):
        base *= 10

from collections import deque
k = int(input())

digsum = lambda x: sum(list(map(int, list(str(x)))))
dignorm = lambda x: x/digsum(x)

n = 1
order = 1
while k > 0:
    print(n)
    k -= 1
    if dignorm(n+10**(order-1)) > dignorm(n+10**order):
        order += 1
    n += 10**(order-1)

res = []
for digit in range(1,16):
    if digit<=3:
        for i in range(2,11):
            res.append(10**(digit-1)*i-1)
    elif 4<=digit<=12:
        for i in range(11,(digit-2)*10):
            res.append(i*10**(digit-2)-1)
        for i in range(digit-2,11):
            res.append(i*10**(digit-1)-1)
    elif digit==15:
        for i in range(101,110):
            res.append(i*10**(digit-3)-1)
        for i in range(11,101):
            res.append(i*10**(digit-2)-1)
    else:
        for i in range(11,101):
            res.append(i*10**(digit-2)-1)
for i in range(int(input())):
    print((res[i]))


K=int(input())

def NS(N):
  NS=0
  while(N>0):
    NS+=N%10
    N//=10
  return NS

answer,diff=0,1
for i in range(K):
  answer+=diff
  print(answer)
  
  if (answer+diff)/NS(answer+diff)>(answer+10*diff)/NS(answer+10*diff):
    diff*=10

def snu(n):
    s=str(n)
    kei=sum(int(x) for x in s)
    return n/kei

def nn(n):
    s=str(n)
    kt=len(str(int(snu(n))))
    if s[-kt:].count("9")==kt:
        if s[-kt-1]=="9":
            n+=10**kt
            s=str(n)
            kt = len(str(int(snu(n))))
            if s[-kt:].count("9") == kt:
                return n
            else:
                s = s[:-kt] + "9" * kt
                return int(s)
        else:
            return n+10**kt
    else:
        s=s[:-kt]+"9"*kt
        return int(s)

k=int(input())
t=9 if k>9 else k
for i in range(1,t+1):
    print(i)
if k<=9:return
n=19
for _ in range(k-9):
    print(n)
    n=nn(n)

from math import log10 as l
s=lambda f:sum(map(int,list(str(f))))
p=lambda a,j:(a//10**(j+1)+1)*10**(j+1)-1
n=int(input())
a=1
for i in range(n):
  print(a)
  if(a<9):
    a+=1
    continue
  a+=1
  k=[p(a,j) for j in range(int(l(a)))]
  o=[p(a,j)/s(p(a,j)) for j in range(int(l(a)))]
  a=k[o.index(min(o))]