#include <bits/stdc++.h>
using namespace std;

#define official

#ifdef official
#define cin inF
#define cout outF
#endif

ifstream inF("intpairs.in");
ofstream outF("intpairs.out");

const long long MOD = 1001234567ll;
const long long MAX_N = 1005;

int n;

long long ans;

void input()
{
    cin >> n;
}

void output()
{
    cout << ans << '\n';
}

long long combs[11][11];

long long facts[11];

void precompCombs()
{
    facts[0] = 1;
    for (int i = 1; i <= 10; ++i)
    {
        facts[i] = facts[i - 1] * i;
    }
    for (int i = 0; i <= 10; ++i)
    {
        for (int j = 0; j <= i; ++j)
        {
            combs[i][j] = (facts[i] / facts[j] / facts[i - j]) % MOD;
        }
    }
}

long long qpows[11][MAX_N];

void precompPows()
{
    for (int k = 1; k <= 10; ++k)
    {
        qpows[k][0] = 1;
        for (int i = 1; i < MAX_N; ++i)
        {
            qpows[k][i] = (qpows[k][i - 1] * k) % MOD;
        }
    }
}

long long modInvs[11];

long long gcdExtended(long long a, long long b, long long& x, long long& y)
{
    if (a == 0)
    {
        x = 0;
        y = 1;
        return b;
    }

    long long x1, y1;
    long long gcd = gcdExtended(b % a, a, x1, y1);

    x = y1 - (b / a) * x1;
    y = x1;

    return gcd;
}

long long calcModInv(long long a)
{
    long long x, y;
    long long g = gcdExtended(a, MOD, x, y);
    return (x % MOD + MOD) % MOD;
}

void precompModInvs()
{
    for (int i = 1; i <= 10; ++i)
    {
        modInvs[i] = calcModInv(i);
    }
}

long long kPrecomp[11];
long long kPrecompZero[11];

void solve()
{
    precompCombs();
    precompPows();
    precompModInvs();

    for (int k = 1; k < 10; ++k)
    {
        for (int digs = k; digs <= n; ++digs)
        {
            long long curr = 0;
            int mul = 1;

            for (int t = 0; t < k; ++t)
            {
                long long toAdd = (mul * combs[k][t] * qpows[k - t][digs]) % MOD;
                if (toAdd < 0) toAdd += MOD;
                curr = (curr + toAdd) % MOD;
                mul *= -1;
            }

            kPrecomp[k] = (kPrecomp[k] + curr) % MOD;
        }

        kPrecompZero[k] = (kPrecomp[k] - kPrecomp[k] * modInvs[k]) % MOD;
        if (kPrecompZero[k] < 0) kPrecompZero[k] += MOD;

        //cerr << k << " - " << kPrecomp[k] << " " << kPrecompZero[k] << endl;
    }

    for (int lk = 1; lk < 10; ++lk)
    {
        for (int rk = 1; rk + lk <= 10; ++rk)
        {
            if (lk + rk < 9) // no zero
            {
                long long lSets = combs[9][lk];
                long long rSets = combs[9 - lk][rk];
                long long toAdd = (lSets * rSets) % MOD;
                toAdd = (toAdd * kPrecomp[lk]) % MOD;
                toAdd = (toAdd * kPrecomp[rk]) % MOD;
                ans += toAdd;
            }

            long long lSets = combs[9][lk - 1];
            long long rSets = combs[10 - lk][rk];
            long long toAdd = (lSets * rSets) % MOD;
            toAdd = (toAdd * kPrecompZero[lk]) % MOD;
            toAdd = (toAdd * kPrecomp[rk]) % MOD;
            toAdd = (toAdd * 2) % MOD;
            ans += toAdd;
        }
    }

    long long totalNum = 1;
    for (int i = 0; i < n; ++i)
    {
        totalNum = (totalNum * 10) % MOD;
    }
    totalNum = ((totalNum - 2) * (totalNum - 1)) % MOD;
    if (totalNum < 0) totalNum += MOD;

    ans = (totalNum - ans) * modInvs[2] % MOD;
    if (ans < 0) ans += MOD;
}

int main()
{
    input();
    solve();
    output();

    return 0;
}