#define _USE_MATH_DEFINES
//#pragma GCC optimize ("Ofast")

#include <iostream>
#include <vector>
#include <set>
#include <math.h>
#include <algorithm>
#include <utility>
#include <map>
#include <string>
#include <iomanip>
#include <unordered_map>
#include <stack>
#include <queue>
#include <random>
#include <list>
#include <string.h>
#include <bitset>
#include <stdio.h>
using namespace std;

typedef long long int LL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<VVI> VVVI;
typedef pair<int, int> II;
typedef vector<II> VII;
typedef vector<VII> VVII;
typedef pair<II, int> III;
typedef vector<III> VIII;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef pair<double, double> DD;
typedef vector<DD> VDD;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;

#define FOR(a, b, c) for (int (a) = (b); (a) < (c); (a)++)
#define REP(a, b) FOR((a), 0, (b))
#define FORD(a, b, c) for (int (a) = (b); (a) >= (c); (a)--)
#define REPD(a, b) FORD((a), (b), 0)
#define PB push_back
#define ITER(it, c) for (auto (it) = (c).begin(); (it) != (c).end(); (it)++)
#define ALL(c) (c).begin(), (c).end()
#define MP make_pair
#define MT(a, b, c) MP(MP((a), (b)), (c))
#define X first
#define Y second
#define FST X.X
#define SND X.Y
#define TRD Y
#define LINF 1e18
#define INF 1e9
#define EPS 1e-9

void naive (int n){
    int k = 0;
    REP(i, n){
        k ++;
        if (to_string(k).find("13") != -1){
            //cout << i << ": " << k << endl;
            i --;
        }
    }
    cout << k << endl;
}

int count13(int n){
    int ans = 0;
    REP(i, n+1){
        if (to_string(i).find("13") != -1)
            ans ++;
    }
    return ans;
}

int log10(int n){
    int ret = -1;
    LL p = 1;
    while(p <= n)
        ret ++, p *= 10;
    return ret;
}

int pow10(int n){
    int ret = 1;
    REP(i, n)
        ret *= 10;
    return ret;
}

map<II, int> dp;

int f (int m, int n){ //13's between m and n
    auto it = dp.find(MP(m, n));
    if (it != dp.end())
        return it->Y;

    int p = log10(n);
    if (pow10(p) == n)
        p --;
    if (p <= 0)
        return 0;
    int ret = 0;
    int i = m; // i = num pos
    while(true){

        if (i == pow10(p)){ //catch the 3

            int d[3] = {3, 1, 6};
            bool done = false;
            int P = pow10(p)/10, start = i;

            REP(k, 3){
                int add = d[k]*P;
                int from = i, to = min(i+add, n);

                if (k == 1)
                    ret += to-from;
                else ret += f(from-start, to-start);

                if (i+add > n){
                    done = true;
                    break;
                }
                i += add;
            }
            if (done)
                break;

        } else {
            int add = pow10(p);
            int from = i, to = min(i+add, n);
            ret += f(0, to-from);
            if (i+add > n){
                break;
            }
            i += add;
        }
    }

    return dp[MP(m, n)] = ret;
}

int main()
{
    ios_base::sync_with_stdio(false);
    int n = 14545352;

    //cout << log10(0) << endl;
    //cout << "f(" << n << ") = " << f(0, n) << endl;
    //cout << ", real is " << count13(n) << endl;

    cin >> n;

    LL bot = 1, top = 2e9;

    while(bot != top){
        int mid = (bot+top+1)/2;
        //cout << bot << ", " << top << endl;
        int ans = mid-f(0, mid); // we want upper bound
        if (ans <= n)
            bot = mid;
        else top = mid-1;
    }
    cout << bot << endl;
    //naive(n);

}