# -*- coding: utf-8 -*-

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache


#############
# Constants #
#############

MOD = 10**9+7
INF = float('inf')

#############
# Functions #
#############

######INPUT######
def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]

#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr

#####LCM#####
def lcm(a, b):
    return a * b // gcd (a, b)

#############
# Main Code #
#############

K = inputI()


l = [[0,0,0,0,0,0,0,0,0,0]]
a = [0]

s = 0
for N in range(1,11):
  if N == 1:
    l.append([1,1,1,1,1,1,1,1,1,1])
  else:
    l.append([
      l[N-1][0]+l[N-1][1],
      l[N-1][0]+l[N-1][1]+l[N-1][2],
      l[N-1][1]+l[N-1][2]+l[N-1][3],
      l[N-1][2]+l[N-1][3]+l[N-1][4],
      l[N-1][3]+l[N-1][4]+l[N-1][5],
      l[N-1][4]+l[N-1][5]+l[N-1][6],
      l[N-1][5]+l[N-1][6]+l[N-1][7],
      l[N-1][6]+l[N-1][7]+l[N-1][8],
      l[N-1][7]+l[N-1][8]+l[N-1][9],
      l[N-1][8]+l[N-1][9]
    ])
  s += sum(l[N][1:])
  a.append(s)
  

N = 1
while K>a[N]:
  N += 1

ans = []

def first_highest(k):
  n = 1
  while k>a[n]:
    n += 1
  k -= a[n-1]
  i = 1
  while k>l[n][i]:
    k -= l[n][i]
    i+=1
  return(n,int(i),k)

N = first_highest(K)[0]
ans.append(first_highest(K)[1])

def later_highest(n,k):
  global ans
  if n > 1:
    i = max(0,ans[-1]-1)
    while k>l[n][i]:
      k -= l[n][i]
      i+=1
    return(n,int(i),k)
  else:
    if ans[-1] == 0:
      return(1,ans[-1]+k-1,0)
    else:
      return(1,ans[-1]+k-2,0)
  
N -= 1
K = first_highest(K)[2]

while N:
  piropiro = later_highest(N,K)
  ans.append(piropiro[1])
  K = piropiro[2]
  N -= 1

ans = map(str,ans)
print("".join(ans))

Measured memory_bytes: 62572