public class Euler551 {
    static final int DMAX = 12;
    static final int CMAX = 9 * DMAX;
    static final int P = 1000000;
    static final int DS6_MAX = 54;
    static final int RMAX = DS6_MAX + CMAX;

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

    static class Tables {
        byte[] ds6 = new byte[P];
        short[][] rem = new short[CMAX + 1][RMAX + 1];
        long[][] steps = new long[CMAX + 1][RMAX + 1];

        Tables() {
            for (int i = 1; i < P; i++) {
                ds6[i] = (byte) (ds6[i / 10] + (i % 10));
            }

            int[] st = new int[P];
            short[] rm = new short[P];
            int[] dsPlusI = new int[P];
            for (int i = 0; i < P; i++)
                dsPlusI[i] = i + ds6[i];

            for (int c = 0; c <= CMAX; c++) {
                for (int i = P - 1; i >= 0; i--) {
                    int y = dsPlusI[i] + c;
                    if (y >= P) {
                        st[i] = 1;
                        rm[i] = (short) (y - P);
                    } else {
                        st[i] = st[y] + 1;
                        rm[i] = rm[y];
                    }
                }
                for (int x = 0; x <= RMAX; x++) {
                    steps[c][x] = st[x];
                    rem[c][x] = rm[x];
                }
            }
        }
    }

    static class Trans {
        short[] next = new short[RMAX + 1];
        long[] cost = new long[RMAX + 1];
    }

    static Trans identityTrans() {
        Trans t = new Trans();
        for (int r = 0; r <= RMAX; r++) {
            t.next[r] = (short) r;
            t.cost[r] = 0;
        }
        return t;
    }

    static Trans compose(Trans a, Trans b) {
        Trans out = new Trans();
        for (int r = 0; r <= RMAX; r++) {
            int mid = a.next[r] & 0xFFFF;
            out.next[r] = b.next[mid];
            out.cost[r] = a.cost[r] + b.cost[mid];
        }
        return out;
    }

    static class BlockBuilder {
        Tables tab;
        long[] pow10 = new long[DMAX + 1];
        Trans[][] block = new Trans[DMAX + 1][CMAX + 1];

        BlockBuilder(Tables tab) {
            this.tab = tab;
            pow10[0] = 1;
            for (int d = 1; d <= DMAX; d++)
                pow10[d] = pow10[d - 1] * 10L;

            for (int ps = 0; ps <= CMAX; ps++) {
                Trans t = new Trans();
                for (int r = 0; r <= RMAX; r++) {
                    t.next[r] = tab.rem[ps][r];
                    t.cost[r] = tab.steps[ps][r];
                }
                block[0][ps] = t;
            }

            for (int d = 1; d <= DMAX; d++) {
                for (int ps = 0; ps + 9 * d <= CMAX; ps++) {
                    Trans tr = block[d - 1][ps];
                    for (int dig = 1; dig <= 9; dig++) {
                        tr = compose(tr, block[d - 1][ps + dig]);
                    }
                    block[d][ps] = tr;
                }
            }
        }

        Trans rangeTrans(long l, long r) {
            Trans res = identityTrans();
            long cur = l;
            while (cur < r) {
                int bestD = 0;
                for (int d = DMAX; d >= 0; d--) {
                    long p = pow10[d];
                    if (p != 0 && cur % p == 0 && cur + p <= r) {
                        bestD = d;
                        break;
                    }
                }
                long p = pow10[bestD];
                long hi = cur / p;
                int ps = digitSum(hi);
                res = compose(res, block[bestD][ps]);
                cur += p;
            }
            return res;
        }
    }

    static long solveA(long n) {
        if (n <= 1)
            return 1;

        Tables tables = new Tables();
        BlockBuilder builder = new BlockBuilder(tables);

        long remainingSteps = n - 1;
        long H = 0;
        int low = 1;

        long lo = 0, hi = 1;
        while (true) {
            Trans tr = builder.rangeTrans(H, H + hi);
            long cost = tr.cost[low];
            if (cost > remainingSteps)
                break;
            lo = hi;
            hi <<= 1;
        }

        while (lo + 1 < hi) {
            long mid = lo + (hi - lo) / 2;
            Trans tr = builder.rangeTrans(H, H + mid);
            long cost = tr.cost[low];
            if (cost <= remainingSteps) {
                lo = mid;
            } else {
                hi = mid;
            }
        }

        Trans finalTr = builder.rangeTrans(H, H + lo);
        long used = finalTr.cost[low];
        int lowAfter = finalTr.next[low] & 0xFFFF;

        H += lo;
        remainingSteps -= used;
        low = lowAfter;

        int c = digitSum(H);
        for (long i = 0; i < remainingSteps; i++) {
            low += (tables.ds6[low] & 0xFF) + c;
        }

        return H * P + low;
    }

    public static String solve() {
        return Long.toString(solveA(1000000000000000L));
    }

    public static void main(String[] args) {
        System.out.println(solve());
    }
}