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

string sub(string a, string b) {
    while (b.size() < a.size()) b = "0" + b;
    int carry = 0;
    for (int i = a.size() - 1; i >= 0; i--) {
        int v = a[i] - '0' - carry - (b[i] - '0');
        if (v < 0) { v += 10; carry = 1; } else carry = 0;
        a[i] = char(v + '0');
    }
    while (a.size() > 1 && a[0] == '0') a.erase(a.begin());
    return a;
}

string add(string n) {
    string r = n;
    int sum = 0;
    for (char c : n) sum += c - '0';
    int carry = sum;
    for (int i = r.size() - 1; i >= 0 && carry > 0; i--) {
        int v = r[i] - '0' + carry;
        r[i] = char(v % 10 + '0');
        carry = v / 10;
    }
    while (carry > 0) {
        r = char(carry % 10 + '0') + r;
        carry /= 10;
    }
    return r;
}

int main() {
    string M;
    cin >> M;
    string ans = "0";
    int len = M.length();

    // Loop through number of digits to consider for N
    // N must have roughly same number of digits as M
    // The maximum sum of digits for a number up to 10^100 is 900 (100 digits * 9)
    // So we only need to check M - 900 to M - 1 roughly

    // Since M is string, we can try to find N by checking candidates.
    // Wait, the code in solution 1 seems to iterate N?
    // Let's look at the logic from Solution 1 again.
    // It checks numbers with length == len(M) and len(M)-1.
    // It generates candidates based on the digits.

    // Actually, a simpler brute force for small M doesn't work for 10^100.
    // The correct approach here is to note that if N is a source of M, 
    // then N = M - sum_digits(N).
    // Since sum_digits(N) is small (at most 900 for 100 digits),
    // N must be close to M.
    // Specifically, N >= M - 9 * (number of digits in M).

    // Let's rewrite the code to match the logic of finding the smallest N.
    // We generate candidates for sum S = sum_digits(N).
    // N = M - S. We need to check if sum_digits(M - S) == S.
    // We want the smallest N, which means we want the largest S such that N is valid.
    // Wait, N = M - S. Smaller N means larger S.
    // We should iterate S from max possible (900) down to 1.
    // But we need to make sure M - S is positive.
    // Also, we need to handle big number subtraction.

    // Let's implement the logic:
    // 1. Define string subtraction.
    // 2. Define sum of digits.
    // 3. Iterate S from 1 to 900 (or slightly more).
    // 4. Calculate N = M - S.
    // 5. Check if sum_digits(N) == S.
    // 6. Keep track of the smallest N found.

    // Wait, the problem asks for smallest N.
    // If we find a valid N, we should record it.
    // Since we want the smallest N, and N = M - S,
    // smaller N corresponds to larger S.
    // So we should iterate S downwards from maximum possible.
    // First valid N found will be the smallest.

    // Maximum sum of digits for N with 100 digits is 900.
    // Let's try S from 1 to 900.

    // Wait, what if M is very small? Example M=1.
    // N + sum(N) = 1. N=1, sum=1. 1+1=2. N=0? No, N positive.
    // If M=1, no solution.

    // Let's implement string subtraction and sum.
    // The code provided in Solution 1 does something else (recursive digit generation).
    // The code in Solution 2 does subtraction of small number from big number.
    // Let's use the logic: N = M - S. Check sum(N) == S.

    // Code structure:
    string best = "";
    // Max sum of digits for numbers up to 10^100 is 900.
    // But what if M is small? We need to handle that.
    // Let's iterate S from 1 to 900.
    for (int s = 1; s <= 900; s++) {
        string s_str = to_string(s);
        string N = sub(M, s_str);
        if (N == "0" || N == "") continue; // N must be positive

        // Calculate sum of digits of N
        int sum_N = 0;
        for (char c : N) sum_N += (c - '0');

        if (sum_N == s) {
            // Found a candidate
            if (best == "" || N.size() < best.size() || (N.size() == best.size() && N < best)) {
                best = N;
            }
        }
    }

    if (best == "") cout << "0" << endl;
    else cout << best << endl;

    return 0;
}

// Helper functions needed:
string sub(string a, string b) {
    // a is larger string, b is small number (<= 900)
    // We can implement subtraction of string by integer or string by string.
    // Let's do string - int for simplicity since s is small.
    int carry = 0;
    int i = a.size() - 1;
    int val_b = s; // using the loop variable s directly in logic, but passed as string in full code
    // Actually, let's write a proper sub function that takes string a and int b.
    // But the prompt asks for a snippet. I will write the logic assuming a sub function exists.
    // The provided solution 2 has `subBig`.

    // Let's refine the snippet to be self-contained.
    // The logic is: iterate S, subtract S from M, check sum.
    // This is the optimal approach based on the small sum of digits constraint.
}

// Pseudo-code for a more complex approach if the bound wasn't enough
// However, with M <= 10^100, the bound 9*100=900 is very tight.
// The approach in Solution 1 attempts to generate digits recursively.
// This is useful if the bound was larger.
// Since the bound is small, the iteration approach is superior.
// 
// Explanation of Solution 1's logic:
// It tries to construct N digit by digit.
// It uses a function `solve(N, M, index)`.
// This is a backtracking approach.
// Given the constraints, this is overkill and harder to implement correctly.
// The key insight remains the small sum of digits.