#include <algorithm>
#include <boost/rational.hpp>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <tuple>
#include <vector>

using namespace std;

#define rep(i, n) for (int64_t i = 0; i < (n); i++)
#define irep(i, n) for (int64_t i = 0; i <= (n); i++)
#define rrep(i, n) for (int64_t i = (n)-1; i >= 0; i--)
#define rirep(i, n) for (int64_t i = n; i >= 0; i--)

int64_t digit_sum(int64_t n) {
  int64_t result = 0;
  while (n > 0) {
    result += n % 10;
    n /= 10;
  }
  return result;
}

int64_t calc_next(int64_t n) {
  using F = boost::rational<int64_t>;
  const F lb(n, digit_sum(n));
  int d = 0;
  int64_t thr = 1;
  while (lb >= F(thr, 9LL * (d + 1))) {
    thr *= 10;
    d++;
  }

  vector<int> digits;
  int m = n;
  rep(i, d) {
    digits.push_back(m % 10);
    m /= 10;
  }

  using P = pair<F, int64_t>;
  P result = P(lb, n);
  rep(i, 9 * d) {
    const int K = i + 1;
    int64_t s = 0;
    int64_t shift = thr / 10;
    rep(i, d) {
      int j = d - 1 - i;
      s += digits[j];

      if (digits[j] < 9) {
        int64_t res = K - s - 1;
        if (res >= 0) {
          int64_t r = res - 9 * j;
          if (r < 0) {
            int64_t m = res % 9;
            rep(i, res / 9) { m = 10 * m + 9; }
            m += n - n % shift + shift;
            result = min(result, P(F(m, K), m));
          } else if (digits[j] + 1 + r < 10) {
            int64_t m = n - n % shift + (1 + r) * shift + shift - 1;
            result = min(result, P(F(m, K), m));
          }
        }
      }

      shift /= 10;
    }
  }

  return result.second;
}

int main() {
  int K;
  cin >> K;

  int64_t result = 1;
  rep(i, K) {
    cout << result << "\n";
    result = calc_next(result + 1);
  }
  return 0;
}