using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;

namespace Atcoder_0404
{
    class Program
    {
        static void Main(string[] args)
        {
            long _needCount = long.Parse(Console.ReadLine());
            List<int> _digits = new List<int>();
            _digits.Add(0);
            long _result =0;
            long nowRonCount=0;
            while (nowRonCount<_needCount)
            {
                var temp=SetNextRon(_digits);
                nowRonCount++;
            }
            _result = ReverseDigit(_digits);
            Console.WriteLine(_result);
        }
        static long ReverseDigit(List<int> data)
        {
            long result = 0;
            for (int i = 0; i<data.Count; i++)
            {
                result += data[i] * (long)Math.Pow(10, i);
            }
            return result;
        }

        static void AddDigit(List<int> data)
        {
            int targetDigit = 0;
            while (true)
            {
                if (targetDigit >= data.Count) data.Add(0);
                data[targetDigit]++;

                int d = data[targetDigit];
                if (d >= 10)
                {
                    data[targetDigit] = 0;
                    targetDigit++;
                }
                else
                {
                    break;
                }
            }
        }


        static List<int> SetNextRon(List<int> data)
        {
            AddDigit(data);
            List<int> result = new List<int>(data);
            int topIndex = data.Count - 1;
            while (!CheckRon(data))
            {
                int def = Math.Abs(data[topIndex] - data[topIndex - 1]);
                if (def >= 2)
                {
                    if (data[topIndex] < data[topIndex-1])
                    {
                        data[topIndex]++;
                        for(int i = 0; i < topIndex; i++)
                        {
                            data[i] = 0;
                        }
                    }
                    data[topIndex - 1] = data[topIndex] - 1;
                    topIndex = data.Count - 1;
                }
                else
                {
                    topIndex--;
                }
            }
            return result;
        }

        static bool CheckRon(List<int> data)
        {
            int targetDigit = 0;
            for (targetDigit = 0; targetDigit < data.Count-1; targetDigit++)
            {
                int difference=Math.Abs(data[targetDigit] - data[targetDigit + 1]);
                if (difference >= 2)
                {
                    return false;
                }
            }
            return true;
        }
        #region input
        

        static string[] GetInput_string()
        {
            var input = Console.ReadLine().Split(' ');
            return input;
        }

        static int[] GetInput_int()
        {
            var input = GetInput_string();
            var result = new int[input.Length];
            for (int i = 0; i < result.Length; i++)
            {
                result[i] = int.Parse(input[i]);
            }
            return result;
        }
        static long[] GetInput_long()
        {
            var input = GetInput_string();
            var result = new long[input.Length];
            for (int i = 0; i < result.Length; i++)
            {
                result[i] = long.Parse(input[i]);
            }
            return result;
        }
        #endregion
        #region sonota
        static void Swap_array<T>(T[] target, int a, int b)
        {
            T temp = target[a];
            target[a] = target[b];
            target[b] = temp;
        }
        static void Swap_list<T>(List<T> target, int a, int b)
        {
            T temp = target[a];
            target[a] = target[b];
            target[b] = temp;
        }
        #endregion
    }
}

Measured memory_bytes: 15308