import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Euler442 {
    private static final long N_TARGET = 1000000000000000000L;

    private static String mulBy11(String s) {
        StringBuilder out = new StringBuilder();
        int carry = 0;
        for (int i = s.length() - 1; i >= 0; i--) {
            int v = 11 * (s.charAt(i) - '0') + carry;
            out.append(v % 10);
            carry = v / 10;
        }
        while (carry > 0) {
            out.append(carry % 10);
            carry /= 10;
        }
        out.reverse();
        int pos = 0;
        while (pos < out.length() - 1 && out.charAt(pos) == '0') {
            pos++;
        }
        return out.substring(pos);
    }

    private static class Node {
        int[] next = new int[10];
        int fail = 0;
        boolean out = false;

        Node() {
            for (int i = 0; i < 10; i++)
                next[i] = -1;
        }
    }

    private static long capAdd(long a, long b, long cap) {
        long s = a + b;
        if (s < 0 || s >= cap)
            return cap;
        return s;
    }

    public static String solve() {
        int maxDigits = 64;
        List<String> patterns = new ArrayList<>();
        String cur = "11";
        while (cur.length() <= maxDigits) {
            patterns.add(cur);
            cur = mulBy11(cur);
        }

        List<Node> nodes = new ArrayList<>();
        nodes.add(new Node());

        for (String p : patterns) {
            int state = 0;
            for (int i = 0; i < p.length(); i++) {
                int d = p.charAt(i) - '0';
                int nx = nodes.get(state).next[d];
                if (nx == -1) {
                    nx = nodes.size();
                    nodes.get(state).next[d] = nx;
                    nodes.add(new Node());
                }
                state = nx;
            }
            nodes.get(state).out = true;
        }

        Queue<Integer> q = new LinkedList<>();
        for (int d = 0; d <= 9; d++) {
            int nx = nodes.get(0).next[d];
            if (nx == -1) {
                nodes.get(0).next[d] = 0;
            } else {
                nodes.get(nx).fail = 0;
                q.add(nx);
            }
        }

        while (!q.isEmpty()) {
            int v = q.poll();
            int f = nodes.get(v).fail;
            if (nodes.get(f).out) {
                nodes.get(v).out = true;
            }
            for (int d = 0; d <= 9; d++) {
                int nx = nodes.get(v).next[d];
                if (nx == -1) {
                    nodes.get(v).next[d] = nodes.get(f).next[d];
                } else {
                    nodes.get(nx).fail = nodes.get(f).next[d];
                    q.add(nx);
                }
            }
        }

        int states = nodes.size();
        long cap = N_TARGET + 1;

        long[][] ways = new long[maxDigits + 1][states];
        for (int s = 0; s < states; s++) {
            ways[0][s] = 1;
        }

        for (int rem = 1; rem <= maxDigits; rem++) {
            for (int s = 0; s < states; s++) {
                if (nodes.get(s).out)
                    continue;
                long sum = 0;
                for (int d = 0; d <= 9; d++) {
                    int ns = nodes.get(s).next[d];
                    if (!nodes.get(ns).out) {
                        sum = capAdd(sum, ways[rem - 1][ns], cap);
                    }
                }
                ways[rem][s] = sum;
            }
        }

        long remaining = N_TARGET;
        int len = 0;
        for (int L = 1; L <= maxDigits; L++) {
            long cnt = 0;
            for (int d = 1; d <= 9; d++) {
                int ns = nodes.get(0).next[d];
                if (!nodes.get(ns).out) {
                    cnt = capAdd(cnt, ways[L - 1][ns], cap);
                }
            }
            if (remaining > cnt) {
                remaining -= cnt;
            } else {
                len = L;
                break;
            }
        }

        if (len == 0)
            return "";

        StringBuilder ans = new StringBuilder();
        int state = 0;
        for (int pos = 0; pos < len; pos++) {
            int startDigit = (pos == 0) ? 1 : 0;
            for (int d = startDigit; d <= 9; d++) {
                int ns = nodes.get(state).next[d];
                if (nodes.get(ns).out)
                    continue;
                long cnt = ways[len - pos - 1][ns];
                if (remaining > cnt) {
                    remaining -= cnt;
                } else {
                    ans.append(d);
                    state = ns;
                    break;
                }
            }
        }

        return ans.toString();
    }

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