#include "vector"
#include "string"
#include "set"
#include "map"
#include "sstream"
#include "algorithm"
#include "cmath"
#include "cassert"
#include "iostream"
#include "numeric"
#include "fstream"
#include "queue"
#include <functional>
#include <climits>
#include <cstring>
#include <ctime>
#include <list>
#include <iomanip>
#include <limits>
#include <unordered_map>
#include <unordered_set>
#include <limits>
#include <complex>
#include <limits>
#include <random>

#define int64 long long int

const int M = 1e9 + 7;

void MultL(int64 &a, int64 b) {
    a = (a * b) % M;
}
void AddL(int64 &a, int64 b) {
    a = (a + (b + M)) % M;
}

int64 Mult(int64 a, int64 b) {
    return (a * b) % M;
}
int64 Add(int64 a, int64 b) {
    return (a + (b + M)) % M;
}

using namespace std;



int get(int n, int k) {
    if (n <= 0) return 0;
    int res = n / (k - 1);
    if (n % (k - 1)) ++res;
    return res;



}
/*

 6 3
5 2 1 3 4 6

 */
int main() {
    std::ios::sync_with_stdio(false);

    /*vector<double> data;
    for (int64 n = 100000000000; n < 100010000000; ++n) {
        string str;
        stringstream stream;
        stream << n;
        stream >> str;
        int r = 0;
        for (int i =0 ; i < str.size(); ++i) {
            r += str[i] - '0';
        }
        double f = double(n) / r;
        data.push_back(f);
        //cout << r << endl;

    }
    for (int i = 0; i < data.size() - 1; ++i) {
        bool good = true;

        for (int j = i + 1; j < data.size(); ++j) {
            if (data[i] > data[j]) {
                good = false;
                break;
            }
        }
        if (good) {
            cout << i + 100000000000 << ' ' << endl;
        }
    }*/

    set<int64> data;
    vector<int64> nines;
    nines.push_back(0);
    for (int nine_number = 0; nine_number < 16; ++nine_number) {
        nines.push_back(nines.back() * 10 + 9);
    }

    for (int nine_number = 0; nine_number < 16; ++nine_number) {
        int64 num = 0;
        while (true) {
            bool good = true;
            ++num;
            int64 num_full = num * (nines[nine_number] + 1) + nines[nine_number];
            if (num_full > 1000000000000000ll) break;

            stringstream stream;
            stream << num;
            string str;
            stream >> str;
            int64 num_dig_sum = nine_number * 9;
            for (int j = int(str.size()) - 1; j >= 0; --j) num_dig_sum += str[j] - '0';
            int64 c_dig_sum = num_dig_sum;

            for (int j = int(str.size()) - 1; j >= 0; --j) {
                c_dig_sum -= str[j] - '0';
                str[j] = '9';
                c_dig_sum += str[j] - '0';
                stream.clear();
                stream << str;
                int64 c;
                stream >> c;
                int64 c_full = c * (nines[nine_number] + 1) + nines[nine_number];

                if (num_full * c_dig_sum > c_full * num_dig_sum) {
                    good = false;
                    break;
                }


            }
            if (! good) break;
            data.insert(num_full);
        }
    }
    int k;
    cin >> k;
    for (auto p : data) {
        if (!k) break;
        cout << p << endl;
        --k;
    }


    return 0;
}








Measured memory_bytes: 256