// https://sio2.mimuw.edu.pl/c/oi32-1/p/zam/
// Zamek cykliczny

#include <bits/stdc++.h>

#define int long long

constexpr int sizik = 1000 * 1001;

#define ar std::array
#define pr std::pair
#define vec std::vector

typedef vec<vec<int>> _kra;

namespace brut {
std::string cyclicShift(const std::string& num) {
    int len = num.size();
    if (len == 1) return num;

    std::string shifted = num.substr(1) + num[0];
    while (shifted.size() > 1 && shifted[0] == '0') {
        shifted.erase(shifted.begin());
    }
    return shifted;
}

int minOperationsToReachOne(const std::string& n) {
    std::unordered_set<std::string> visited;
    std::queue<std::pair<std::string, int>> q;

    q.push({n, 0});
    visited.insert(n);

    while (!q.empty()) {
        auto [current, steps] = q.front();
        q.pop();

        if (current == "1") {
            return steps;
        }

        std::string addOne = std::to_string(stoll(current) + 1);
        if (visited.find(addOne) == visited.end()) {
            visited.insert(addOne);
            q.push({addOne, steps + 1});
        }

        std::string shifted = cyclicShift(current);
        if (visited.find(shifted) == visited.end()) {
            visited.insert(shifted);
            q.push({shifted, steps + 1});
        }
    }

    return -1;
}

}

std::string removeLeadingZeroes(const std::string& input) {
    size_t nonZeroPos = input.find_first_not_of('0');

    if (nonZeroPos == std::string::npos) {
        return "0";
    }

    return input.substr(nonZeroPos);
}

int solve_for_one_digit(char c) {
    if (c == '1') {
        return 0;
    }

    return (11 - (c - '0'));
}

constexpr int HOW_MIK = 7;
constexpr int INF = INT64_MAX;

int classic_count_op(const std::string& local_n) {
    int ans = 0;
    int l = local_n.size();

    int num_ofNot9 = 0;
    for (const auto& c : local_n) {
        if (c != '9') num_ofNot9++;
    }

    if (local_n.back() != '9' && local_n.back() != '0') {
        ans += 9 - (local_n.back() - '0');
        num_ofNot9--;
    }

    int i = 0;
    while (num_ofNot9 > 0) {
        if (local_n[i] != '0') {
            ans += 9 - (local_n[i] - '0') + 1;
            if (local_n[i] != '9') {
                num_ofNot9--;
            }
        } else {
            num_ofNot9--;
        }
        i++;
    }

    return ans;
}

std::string int_to_2(int x) {
    return std::bitset<8>(x).to_string();
}

void solve() {
    std::string n;
    std::cin >> n;

    n = removeLeadingZeroes(n);
    if (n == "0") {
        std::cout << "1\n";
        return;
    }

    int l = n.size();

#ifndef GARY_DBG
    if (l <= 6) {
        std::cout << brut::minOperationsToReachOne(n) << '\n';
        return;
    }
#endif

    if (l == 1) {
        int ansix = solve_for_one_digit(n[0]);
        std::cout << ansix << '\n';

        return;
    }

    int num_of0 = 0;
    for (const auto& c : n) {
        if (c == '0') num_of0++;
    }

    if (num_of0 + 1 == l) {
        int ansix = solve_for_one_digit(n[0]) + 1;
        std::cout << ansix << '\n';

        return;
    }

    int ans = INF;
    int local_HOW_MIK = std::min(HOW_MIK, l);

    for (int i = 0; i < (1 << local_HOW_MIK); i++) {
        int tmp = i, local_ans = 0;
        std::string copy_n = n;
        for (int j = l - 1, k = 0; k < local_HOW_MIK; j--, k++) {
            if ((tmp % 2) == 1) {
                // dodaj ..
                local_ans += (9 - (n[j] - '0')) * pow(10, k);
                copy_n[j] = '9';
            }

            tmp /= 2;
        }

        int dod_op = classic_count_op(copy_n);

        local_ans += 2 + dod_op;

        ans = std::min(ans, local_ans);
    }

    std::cout << ans << '\n';
}

int32_t main() {
#ifndef GARY_DBG
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);
#endif

    int t = 1;
    // std::cin >> t;

    for (; t > 0; t--) {
        solve();
    }

    return 0;
}