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

typedef long long ll;
const int MOD = 998244353;

ll L, R, k;
ll arr[22]; // Lưu các chữ số của số đang xét
ll pow10[22]; // Mảng lũy thừa 10

// F[id][mask][leadingZero]: pair<count, sum>
// id: vị trí chữ số đang xét (từ cao xuống thấp)
// mask: bitset thể hiện các chữ số đã xuất hiện
// leadingZero: boolean, true nếu các chữ số trước đều là 0
pair<ll, ll> f[22][1 << 10][2];
bool exist[22][1 << 10][2];

pair<ll, ll> Calc(int id, int mask, bool tight, bool leadingZero) {
    if (id == 0) { // Đã xét hết các chữ số
        // Nếu không phải toàn bộ số 0 và số lượng chữ số phân biệt <= k
        if (!leadingZero && __builtin_popcount(mask) <= k) {
            return {1, 0}; // 1 cách, tổng là 0 (vì đây là chữ số cuối)
        }
        return {0, 0};
    }

    // Nếu không bị giới hạn (tight) và đã tính rồi thì trả về kết quả nhớ
    if (!tight && exist[id][mask][leadingZero]) {
        return f[id][mask][leadingZero];
    }

    pair<ll, ll> res = {0, 0};
    int maxDigit = tight ? arr[id] : 9;

    for (int digit = 0; digit <= maxDigit; digit++) {
        bool newTight = tight && (digit == maxDigit);
        bool newLz = leadingZero && (digit == 0);
        int newMask = mask;

        // Nếu không phải là số 0 đứng đầu thì cập nhật mask
        if (!newLz) {
            newMask |= (1 << digit);
        }

        pair<ll, ll> cur = Calc(id - 1, newTight, newMask, newLz);

        // Cập nhật số lượng
        res.first = (res.first + cur.first) % MOD;

        // Cập nhật tổng
        // cur.second là tổng các số tạo thành từ các chữ số sau
        // cur.first là số lượng các số đó
        // digit * pow10[id-1] là giá trị đóng góp của chữ số hiện tại
        res.second = (res.second + cur.second + (ll)digit * pow10[id - 1] % MOD * cur.first % MOD) % MOD;
    }

    if (!tight) {
        exist[id][mask][leadingZero] = true;
        f[id][mask][leadingZero] = res;
    }
    return res;
}

ll solve(ll n) {
    if (n == 0) return 0;
    // Phân tích n thành các chữ số
    int len = 0;
    while (n > 0) {
        arr[++len] = n % 10;
        n /= 10;
    }
    // Đảo mảng để arr[1] là chữ số cao nhất
    for (int i = 1; i <= len / 2; i++) swap(arr[i], arr[len - i + 1]);

    // Reset DP state (hoặc chỉ cần thay đổi cách đánh dấu)
    // Ở đây ta dùng mảng exist, cần clear trước
    memset(exist, 0, sizeof(exist));

    return Calc(len, 0, true, true).second;
}

int main() {
    // Tính lũy thừa 10
    pow10[0] = 1;
    for (int i = 1; i <= 19; i++) pow10[i] = (pow10[i-1] * 10) % MOD;

    cin >> L >> R >> k;

    ll ansR = solve(R);
    ll ansL = solve(L - 1);

    ll ans = (ansR - ansL + MOD) % MOD;
    cout << ans << endl;
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long ll;
const int MOD = 998244353;

string S;
int K;
ll power_of_10[20];

// dp[pos][mask][tight][is_leading_zero]
// Lưu số lượng số hợp lệ
ll dp_cnt[20][1 << 10][2][2];
// Lưu tổng của các số hợp lệ
ll dp_sum[20][1 << 10][2][2];
bool visited_cnt[20][1 << 10][2][2];
bool visited_sum[20][1 << 10][2][2];

ll count_valid(int pos, int mask, bool tight, bool is_leading_zero) {
    if (pos == S.size()) {
        if (!is_leading_zero && __builtin_popcount(mask) <= K) return 1;
        return 0;
    }
    if (visited_cnt[pos][mask][tight][is_leading_zero]) return dp_cnt[pos][mask][tight][is_leading_zero];

    ll res = 0;
    int upper = tight ? (S[pos] - '0') : 9;

    for (int d = 0; d <= upper; ++d) {
        bool new_tight = tight && (d == upper);
        bool new_leading = is_leading_zero && (d == 0);
        int new_mask = new_leading ? mask : (mask | (1 << d));
        res = (res + count_valid(pos + 1, new_mask, new_tight, new_leading)) % MOD;
    }

    visited_cnt[pos][mask][tight][is_leading_zero] = true;
    dp_cnt[pos][mask][tight][is_leading_zero] = res;
    return res;
}

ll sum_valid(int pos, int mask, bool tight, bool is_leading_zero) {
    if (pos == S.size()) {
        return 0; // Base case sum is 0 (no digit added)
    }
    if (visited_sum[pos][mask][tight][is_leading_zero]) return dp_sum[pos][mask][tight][is_leading_zero];

    ll res = 0;
    int upper = tight ? (S[pos] - '0') : 9;

    for (int d = 0; d <= upper; ++d) {
        bool new_tight = tight && (d == upper);
        bool new_leading = is_leading_zero && (d == 0);
        int new_mask = new_leading ? mask : (mask | (1 << d));

        // Nếu chọn d tại đây, d sẽ là chữ số có trọng số là 10^(len - 1 - pos)
        // Ví dụ: 123, pos=0 (chữ số 1), tổng trọng số là 100. Pos=2 (chữ số 3), tổng trọng số là 1.
        ll weight = power_of_10[S.size() - 1 - pos];
        ll contribution = (d * weight) % MOD;

        // Số lượng các số hợp lệ tạo thành từ phần đuôi
        ll count = count_valid(pos + 1, new_mask, new_tight, new_leading);

        // Tổng các số tạo thành từ phần đuôi (chữ số đầu là 0 trong phần đuôi)
        ll sub_sum = sum_valid(pos + 1, new_mask, new_tight, new_leading);

        // Tổng tại bước này = (d * weight * count) + sub_sum
        ll term = (contribution * count) % MOD;
        term = (term + sub_sum) % MOD;

        res = (res + term) % MOD;
    }

    visited_sum[pos][mask][tight][is_leading_zero] = true;
    dp_sum[pos][mask][tight][is_leading_zero] = res;
    return res;
}

ll solve(ll n) {
    if (n == 0) return 0;
    S = to_string(n);
    memset(visited_cnt, 0, sizeof(visited_cnt));
    memset(visited_sum, 0, sizeof(visited_sum));
    return sum_valid(0, 0, true, true);
}

int main() {
    power_of_10[0] = 1;
    for (int i = 1; i < 20; ++i) power_of_10[i] = (power_of_10[i - 1] * 10) % MOD;

    ll L, R;
    cin >> L >> R >> K;

    ll ans = (solve(R) - solve(L - 1) + MOD) % MOD;
    cout << ans << endl;
    return 0;
}