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

long long dp[20][165][2];
string num;
int target_sum;

// Hàm quy hoạch động đếm số số <= num có tổng chữ số bằng target_sum
long long f(int pos, int sum, bool tight) {
    if (sum < 0) return 0;
    if (pos == num.size()) return (sum == 0);

    if (dp[pos][sum][tight] != -1) return dp[pos][sum][tight];

    long long res = 0;
    int limit = tight ? num[pos] - '0' : 9;

    for (int digit = 0; digit <= limit; ++digit) {
        res += f(pos + 1, sum - digit, tight && (digit == limit));
    }

    return dp[pos][sum][tight] = res;
}

// Đếm số số <= x có tổng chữ số bằng S
long long count_up_to(long long x, int s) {
    if (x < 0) return 0;
    num = to_string(x);
    target_sum = s;
    memset(dp, -1, sizeof(dp));
    return f(0, s, true);
}

// Tìm số nhỏ nhất trong [A, B] có tổng chữ số bằng S
long long find_smallest(long long A, long long B, int S) {
    long long lo = A, hi = B, ans = -1;
    while (lo <= hi) {
        long long mid = lo + (hi - lo) / 2;
        // Nếu t tồn tại số <= mid trong [A, B] có tổng S (tức là count_up_to(mid, S) > count_up_to(A-1, S))
        if (count_up_to(mid, S) > count_up_to(A - 1, S)) {
            ans = mid;
            hi = mid - 1;
        } else {
            lo = mid + 1;
        }
    }
    return ans;
}

int main() {
    long long A, B;
    int S;
    if (cin >> A >> B >> S) {
        // Câu 1: Đếm số lượng
        long long cnt = count_up_to(B, S) - count_up_to(A - 1, S);
        cout << cnt << "\n";

        // Câu 2: Tìm số nhỏ nhất
        cout << find_smallest(A, B, S) << "\n";
    }
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

long long A, B;
int S;

// Hàm tạo số nhỏ nhất có tổng chữ số là sum và có ít nhất min_len chữ số
string construct_min(int sum, int min_len) {
    string res = "";
    // Nếu tổng lớn hơn 9*(min_len-1), ta phải dùng thêm chữ số
    // Tính số lượng chữ số tối thiểu cần thiết
    int needed_len = min_len;
    while (needed_len * 9 < sum) needed_len++;

    // Xây dựng số từ trái sang phải
    int current_sum = sum;
    for (int i = 0; i < needed_len; i++) {
        int remaining_len = needed_len - i - 1;
        // Chọn digit nhỏ nhất để lại t tổng khả thi cho phần còn lại
        // Phần còn lại cần tối thiểu 0 (nếu là số 0 được phép ở đầu, nhưng số không được bắt đầu bằng 0)
        // Nếu i==0, digit tối thiểu là 1. Nếu i > 0, digit tối thiểu là 0.
        int min_digit = (i == 0) ? 1 : 0;

        // Digit phải đủ lớn để phần còn lại có thể đạt được tổng current_sum - digit
        // Phần còn lại tối đa là 9 * remaining_len
        // Điều kiện: current_sum - digit <= 9 * remaining_len
        // => digit >= current_sum - 9 * remaining_len

        for (int d = min_digit; d <= 9; d++) {
            if (current_sum - d <= 9 * remaining_len) {
                res += (char)(d + '0');
                current_sum -= d;
                break;
            }
        }
    }
    return res;
}

// Kiểm tra xem số n có tổng chữ số bằng S không
int get_sum(long long n) {
    int s = 0;
    while (n > 0) {
        s += n % 10;
        n /= 10;
    }
    return s;
}

int main() {
    cin >> A >> B >> S;

    // Câu 1: Đếm số lượng (Dùng brute force nếu đoạn nhỏ, nhưng ở đây B-A có thể lớn.
    // Tuy nhiên, giải pháp này tập trung vào câu 2 và tối ưu cho câu 1 nếu cần.
    // Do bài này yêu cầu cả 2, Digit DP vẫn tốt hơn. Code này minh họa cho finding).

    // Câu 2: Tìm số nhỏ nhất
    // Ta cần tìm số X sao cho A <= X <= B và tổng X = S.
    // Ta thử tạo số Y có tổng S sao cho Y >= A. Nếu Y <= B thì đó là đáp án.
    // Cách 1: Tạo số nhỏ nhất >= A có tổng S.

    long long ans = -1;

    // Thử các độ dài số từ len(A) đến len(B)
    string strA = to_string(A);
    string strB = to_string(B);
    int lenA = strA.length();
    int lenB = strB.length();

    // 1. Nếu tạo số có độ dài > lenA, số nhỏ nhất là tạo số có tổng S với độ dài đó (luôn >= A)
    // 2. Nếu tạo số có độ dài == lenA, phải đảm bảo >= A

    // Ưu tiên độ dài bằng lenA trước
    // Duyệt các cấu hình chữ số từ phải sang trái hoặc dùng DFS/Backtracking

    // Hàm tìm số nhỏ nhất >= lower_bound và <= upper_bound có tổng S
    // khá phức tạp để code hoàn chỉnh trong ngắn gọn.
    // Dưới đây là logic tìm số nhỏ nhất >= A có tổng S:

    // Logic:
    // Xét các độ dài từ len(A) đến len(B).
    // Nếu độ dài > len(A): Số đó chắc chắn > A. Tạo số nhỏ nhất có tổng S và độ dài đó.
    // Nếu độ dài == len(A): Tạo số >= A có tổng S.
    //    Quét từ trái sang phải, cố gắng giữ nguyên chữ số của A (để số nhỏ nhất).
    //    Nếu không thể (tổng quá lớn hoặc nhỏ), phải điều chỉnh.

    // Code dưới đây chỉ giải quyết câu hỏi 2 một cách trực quan:
    // Tạo số nhỏ nhất >= A có tổng S.

    // DFS tìm số nhỏ nhất >= lower_bound
    // Trạng thái: (pos, sum, tight)
    string res = "-1";

    // Chỉ giải quyết câu hỏi 2:
    // Dùng DFS để tìm số nhỏ nhất >= A và <= B có tổng S

    // Do code full cho constructive approach này khá dài, ta sẽ chỉ ghi concept:
    // Dùng recursion thử các chữ số.

    // Tuy nhiên, với dữ liệu lớn, Digit DP là lựa chọn tối ưu và an toàn nhất.
    // Approach này thường dùng khi số lượng query lớn hoặc bài toán khác.

    // Ví dụ đơn giản: Tạo số nhỏ nhất >= A có tổng S:
    // 1. Tính tổng chữ số hiện tại của A (curSum).
    // 2. Nếu curSum == S -> A là đáp án.
    // 3. Nếu curSum < S: Ta cần cộng thêm (S - curSum). Cố gắng cộng vào các chữ số cuối.
    //    Ví dụ A=100, S=3 -> 102.
    // 4. Nếu curSum > S: Khó hơn. Phải sửa các chữ số.

    // Ví dụ A=199, S=10 -> 199 (sum=19) > 10. Phải sửa.
    // Tăng A lên 200 (sum=2) -> 208 (sum=10).

    // Kết luận: Digit DP là cách tốt nhất cho bài này.
    // Approach này chỉ hiệu quả nếu bài toán yêu cầu tối ưu hóa thêm (vd: chỉ tìm số, không đếm).
    // Hoặc dùng làm bước tiền xử lý.

    return 0;
}

#include <iostream>
using namespace std;

// Chỉ dùng cho B-A nhỏ (ví dụ < 10^6)
// Bài này B-A có thể lên tới 10^15, code này sẽ chạy quá thời gian
int get_sum(long long n) {
    int s = 0;
    while (n > 0) {
        s += n % 10;
        n /= 10;
    }
    return s;
}

int main() {
    long long A, B;
    int S;
    cin >> A >> B >> S;

    long long count = 0;
    long long first = -1;

    // DANGER: Vòng lặp này chạy 10^15 lần, quá chậm
    for (long long i = A; i <= B; i++) {
        if (get_sum(i) == S) {
            count++;
            if (first == -1) first = i;
        }
    }

    cout << count << endl;
    cout << first << endl;
    return 0;
}