#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <bitset>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <string>
#include <chrono>
#include <random>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <functional>
#include <sstream>

using namespace std;


struct Datum {
    Datum(int _s = 0, long long _x = 0) : s(_s), x(_x) {
    }

    bool operator == (const Datum& other) const {
        return x == other.x && s == other.s;
    }

    bool operator< (const Datum& other) const {
        if (x * other.s == other.x * s) {
            return x < other.x;
        } 
        return x * other.s < other.x * s;        
    }

    bool operator > (const Datum& other) const {
        if (x * other.s == other.x * s) {
            return x > other.x;
        } 
        return x * other.s > other.x * s;
    }

    Datum next() {
        long long res = x;
        long long b = 1;
        long long rem = 0;
        while (res != 0) {
            int d = res % 10;
            b *= 10;
            res /= 10;
            if (d != 0) {
                res += 1;
                break;
            }
        }
        rem = s - calc(res);
        res = res * b + smallest(rem).x;
        return Datum(s, res);
    }

    Datum next(long long y) {
        vector<int> ds;
        long long b = 1;
        long long MN = y;
        while (y != 0) {
            ds.push_back(y % 10);
            y /= 10;
            b *= 10;
        }
        ds.push_back(0);
        b *= 10;
        reverse(ds.begin(), ds.end());
        // cout << "NEXT " << s << " " << MN << endl;
        long long pre = 0;
        long long res = 1LL << 60;
        for (auto d : ds) {
            pre = pre * 10 + d;
            long long ans = pre + 1;
            b /= 10;
            long long rem = s - calc(ans);
            if (rem < 0) {
                continue;
            }
            ans = ans * b + smallest(rem).x;
            if (ans > MN && calc(ans) == s) {
                // cout << " a " << ans << " " << rem <<  endl;
                res = min(res, ans);
            }
        }
        // cout << res << endl;
        return Datum(s, res);
    }


    static int calc(long long x) {
        int res = 0;
        while (x > 0) {
            res += x % 10;
            x /= 10;
        }
        return res;
    }

    static Datum smallest(int sum) {
        long long res = 0;
        long long b = 1;
        Datum ans(sum);
        while (sum > 0) {
            int d = min(9, sum);
            sum -= d;
            res += d * b;
            b *= 10;
        }
        ans.x = res;
        return ans;
    }

    long long x;
    int s;
};

int main(int argc, char** argv) {
    ios::sync_with_stdio(false);
    cin.tie(0);


    int k;
    cin >> k;


    priority_queue<Datum, vector<Datum>, greater<Datum>> pq; 

    const int N = 135 + 4;
    for (int i = 1; i <= N; ++i) {
        Datum D = Datum::smallest(i);
        // cout << D.s << " " << D.x << endl;
        pq.emplace(D);
    }

    long long x = 0;
    long long LIMIT = 1e15 + 1;

    
    while (!pq.empty() && k > 0) {
        auto D = pq.top();
        pq.pop();

        if (D.x > x) {
            // cout << D.s << " " << D.x << endl;

            cout << D.x << endl;
            if (--k == 0) {
                break;
            }
            x = D.x;
        }
        D = D.next(x);
        // cout << D.x << endl;
        if (D.x < LIMIT) {
            pq.emplace(D);
        }
    }

    return 0;
}

Measured memory_bytes: 3632