You are given two integers l and r (l ≤ r). Your task is to calculate the sum of numbers from l to r (including l and r) such that each number contains at most k different digits, and print this sum modulo 998244353.

For example, if k = 1 then you have to calculate all numbers from l to r such that each number is formed using only one digit. For l = 10, r = 50 the answer is 11 + 22 + 33 + 44 = 110.

Input

The only line of the input contains three integers l, r and k (1 ≤ l ≤ r < 10^{18}, 1 ≤ k ≤ 10) — the borders of the segment and the maximum number of different digits.

Output

Print one integer — the sum of numbers from l to r such that each number contains at most k different digits, modulo 998244353.

Examples

Input

10 50 2


Output

1230


Input

1 2345 10


Output

2750685


Input

101 154 2


Output

2189

Note

For the first example the answer is just the sum of numbers from l to r which equals to (50 ⋅ 51)/(2) - (9 ⋅ 10)/(2) = 1230. This example also explained in the problem statement but for k = 1.

For the second example the answer is just the sum of numbers from l to r which equals to (2345 ⋅ 2346)/(2) = 2750685.

For the third example the answer is 101 + 110 + 111 + 112 + 113 + 114 + 115 + 116 + 117 + 118 + 119 + 121 + 122 + 131 + 133 + 141 + 144 + 151 = 2189.
#include <bits/stdc++.h>
using namespace std;
template <class T>
long long size(const T &x) {
  return x.size();
}
const long long INF = ~(1 << 31);
const double pi = acos(-1);
const double EPS = 1e-9;
string comp;
long long sz;
long long distinct;
pair<long long, long long> memo[20][(1 << 12)][3];
bool vis[20][(1 << 12)][3];
long long mod = 998244353;
long long pw(long long a, long long v) {
  long long start = 1;
  for (long long i = (0); i < (v); i++) {
    start *= a;
    start %= mod;
  }
  return start;
}
pair<long long, long long> num_ways(long long at, long long bitmask,
                                    long long isgreater) {
  long long nb = __builtin_popcount(bitmask);
  if (nb > distinct) return pair<long long, long long>(0, 0);
  if (at >= sz) {
    if (isgreater) return pair<long long, long long>(0, 0);
    return pair<long long, long long>(0, 1);
  }
  if (vis[at][bitmask][isgreater]) return memo[at][bitmask][isgreater];
  long long sum = 0;
  long long nm_ws = 0;
  for (long long i = (at != sz - 1 ? 0 : 1); i < (10); i++) {
    if (i == comp[at] - '0') {
      pair<long long, long long> asn =
          num_ways(at + 1, bitmask | (1 << i), isgreater);
      if (i != 0 && at != sz - 1 &&
          __builtin_popcount(bitmask | (1 << i)) <= distinct) {
        asn.second += 1;
      }
      asn.second %= mod;
      asn.first %= mod;
      sum += asn.first;
      sum %= mod;
      sum += ((((asn.second * pw(10, at)) % mod) * i) % mod);
      sum %= mod;
      nm_ws += asn.second;
      nm_ws %= mod;
    } else if (i < comp[at] - '0') {
      pair<long long, long long> asn = num_ways(at + 1, bitmask | (1 << i), 0);
      if (i != 0 && at != sz - 1 &&
          __builtin_popcount(bitmask | (1 << i)) <= distinct) {
        asn.second += 1;
      }
      asn.second %= mod;
      asn.first %= mod;
      sum += asn.first;
      sum %= mod;
      sum += ((((asn.second * pw(10, at)) % mod) * i) % mod);
      sum %= mod;
      nm_ws += asn.second;
      nm_ws %= mod;
    } else {
      pair<long long, long long> asn = num_ways(at + 1, bitmask | (1 << i), 1);
      if (i != 0 && at != sz - 1 &&
          __builtin_popcount(bitmask | (1 << i)) <= distinct) {
        asn.second += 1;
      }
      asn.second %= mod;
      asn.first %= mod;
      sum += asn.first;
      sum %= mod;
      sum += ((((asn.second * pw(10, at)) % mod) * i) % mod);
      sum %= mod;
      nm_ws += asn.second;
      nm_ws %= mod;
    }
  }
  vis[at][bitmask][isgreater] = true;
  return memo[at][bitmask][isgreater] =
             pair<long long, long long>(sum % mod, nm_ws % mod);
}
pair<long long, long long> calc(long long n, long long k) {
  if (n <= 0) return pair<long long, long long>(0, 0);
  comp = to_string(n);
  reverse(comp.begin(), comp.end());
  memset(vis, 0, sizeof(vis));
  sz = comp.size();
  distinct = k;
  return num_ways(0, 0, 0);
}
int main() {
  cin.sync_with_stdio(false);
  long long L, R, K;
  cin >> L >> R >> K;
  cout << (calc(R, K).first - calc(L - 1, K).first + mod) % mod << endl;
  return 0;
}
