#!/usr/bin/python3

import math
from functools import cache


@cache
def fact(x: int) -> int:
    if x == 1 or x == 0:
        return 1
    return fact(x-1) * x


fact_table = {fact(x): x for x in range(10)}


def count_digits(d: dict[int, int]):
    digit_count = 0
    for k, v in d.items():
        digit_count += v
    return digit_count


def format(d: dict[int, int]):
    l1 = list(sorted(d.items()))
    res = list(map(lambda tp: str(tp[0]) * tp[1], l1))
    if res[0][0] == '0':
        res[0] = f'1{res[0][1:]}'
    return ''.join(res)


def gt(d1: dict[int, int], d2: dict[int, int]):
    len1 = count_digits(d1)
    len2 = count_digits(d2)
    if len1 > len2:
        return True
    if len2 > len1:
        return False

    l1 = list(sorted(d1.items()))
    l2 = list(sorted(d2.items()))
    for i1, i2 in zip(l1, l2):
        if i1[0] > i2[0]:
            return True
        if i1[1] > i2[1]:
            return True
    return False


best_res = None
best_res_digits = None


def solve(serial: int, current_res: dict[int, int], curr_sum: int = 0, log = 0) -> None:
    global best_res
    global best_res_digits
    # print(f'{serial=}, {current_res=}, {curr_sum=}')

    if best_res is not None and (gt(current_res, best_res) or best_res_digits < log):
        return

    if curr_sum == serial:
        if best_res == None or gt(best_res, current_res):
            best_res = current_res
            best_res_digits = log
        return

    for i in range(9, -1, -1):
        if i in current_res:
            continue

        factorial = fact(i)

        if factorial > (serial - curr_sum):
            continue

        div = (serial - curr_sum) // factorial

        next_sum = curr_sum + div*factorial
        next_res = current_res.copy()
        next_res[i] = div

        solve(serial, next_res, next_sum, log+div)


y = int(input())

solve(y, {}) 
print(format(best_res))