#include <bits/stdc++.h>
using namespace std;
namespace io {
const long long SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
                                       qu[55];
long long f, qr;
inline void flush() {
  fwrite(obuf, 1, oS - obuf, stdout);
  oS = obuf;
}
inline void putc(char x) {
  *oS++ = x;
  if (oS == oT) flush();
}
template <class I>
inline void gi(I& x) {
  for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                              (iS == iT ? EOF : *iS++))
                            : *iS++);
       c < '0' || c > '9';
       c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                       (iS == iT ? EOF : *iS++))
                     : *iS++))
    if (c == '-') f = -1;
  for (x = 0; c <= '9' && c >= '0';
       c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                       (iS == iT ? EOF : *iS++))
                     : *iS++))
    x = x * 10 + (c & 15);
  x *= f;
}
template <class I>
inline void print(I x) {
  if (!x) putc('0');
  if (x < 0) putc('-'), x = -x;
  while (x) qu[++qr] = x % 10 + '0', x /= 10;
  while (qr) putc(qu[qr--]);
}
struct Flusher_ {
  ~Flusher_() { flush(); }
} io_flusher_;
}  // namespace io
const long long maxn = 100000 + 7, ex[] = {0,
                                           1,
                                           10,
                                           100,
                                           1000,
                                           10000,
                                           100000,
                                           1000000,
                                           10000000,
                                           100000000,
                                           1000000000,
                                           10000000000,
                                           100000000000,
                                           1000000000000,
                                           10000000000000,
                                           100000000000000,
                                           1000000000000000};
long long n, tot, a[maxn], deta;
long long ans;
inline long long Find(long long l, long long r, long long x) {
  while (l < r) {
    int m = (l + r) >> 1;
    if (a[m] >= x)
      r = m;
    else
      l = m + 1;
  }
  return l;
}
long long Sum(long long x) {
  long long ans = 0;
  while (x) ans += x % 10, x /= 10;
  return ans;
}
int main() {
  io::gi(n);
  a[1] = 9, a[2] = 18;
  deta = 10;
  for (register long long i = 3; i <= n; ++i) deta += 9, a[i] = a[i - 1] + deta;
  for (register long long i = 1; i <= n; ++i) {
    int p = Find(1, n, i);
    if (i <= a[p] && i >= a[p - 1]) ans += ex[p];
    io::print(ans);
    io::putc(10);
  }
}
