#include <string>
#include <iostream>
#include <vector>
#include <sstream>
#include <utility>
#include <chrono>
using ull = unsigned long long;

struct Ull
{
    std::string str;
    ull offset = 0;
    bool allAlpha = false;

    std::size_t size() const
    {
        return str.size() + offset;
    }

    std::string substr(Ull const& next) const
    {
        std::stringstream stream;

        std::size_t len = std::min(str.size(), next.size());
        if (str.size()<next.size())
        {
            stream << std::string(size()-1-next.size(), '0');
        }
        else 
        {
            std::size_t len = size() - next.size() - 1;
            stream << str.substr(next.size(), str.size()-next.size());
            len -= (str.size()-next.size());
            stream << std::string(len,'0');
        }
        return stream.str();
    }

    std::string print() const
    {
        return str + std::string(offset,'0');
        // return str;
    }

    std::string data() const
    {
        // return print() + " : " + std::to_string(offset);
        return print();
    }
};

bool compare(std::string const& fst, std::string const& next)
{
    if (fst.size() != next.size())
    {
        return fst.size() >= next.size();
    }
    for (std::size_t i = 0; i<fst.size(); ++i)
    {
        if (fst.at(i) != next.at(i))
        {
            return fst.at(i) >= next.at(i);
        }
    }

    return true;
}

bool compare(Ull const& fst, Ull const& snd)
{
    if (fst.size() != snd.size())
    {
        return fst.size() >= snd.size();
    }

    for (std::size_t i = 0; i<fst.str.size(); ++i)
    {
        if (fst.str.at(i) != snd.str.at(i))
        {
            return fst.str.at(i) >= snd.str.at(i);
        }
    }
    for (std::size_t i = fst.str.size(); i<fst.size(); ++i)
    {
        if ('0' != snd.str.at(i))
        {
            return '0' >= snd.str.at(i);
        }
    }

    return true;
}

int samePrefix(std::string const& fst, std::string const& next)
{
    return fst.compare(0, next.size(), next);
}

int samePrefix(Ull const& fst, Ull const& next)
{
    if (fst.offset == 0)
    {
        return fst.str.compare(0, next.size(), next.str);
    }

    if (fst.str.size() > next.size())
    {
        return fst.str.compare(0, next.size(), next.str);
    }
    for (std::size_t i = 0; i<fst.str.size(); ++i)
    {
        if (fst.str.at(i) != next.str.at(i))
        {
            return fst.str.at(i) - next.str.at(i);
        }
    }
    for (std::size_t i = fst.str.size(); i<next.size(); ++i)
    {
        if ('0' != next.str.at(i))
        {
            return '0' - next.str.at(i);
        }
    }

    return 0;
}

std::string getNext(Ull & fst1, Ull & next1)
{
    auto const& fst = fst1.str;
    auto const& next = next1.str;
    std::stringstream stream;
    stream << next;

    if (fst1.size() == next1.size())
    {
        fst1.allAlpha = true;
        fst1.offset = 1;

        return next;
    }
    int pref = samePrefix(fst1, next1);

    if (pref == 0)
    {

        if (fst1.offset == 0)
        {
            stream << fst.substr(next.size(), fst.size()-1-next.size());

            if (fst.back() == '9')
                stream << "90";
            else 
                stream << (char)(fst.at(fst.size()-1) + 1);
            }
        else
        {
            stream << fst1.substr(next1);
            stream << '1';
        }
        fst1.offset = 0;
        fst1.allAlpha = false;
    }
    else
    {
        // std::cout << fst1.data() << " " << next1.data() << std::endl;
        fst1.allAlpha = true;
        fst1.offset = fst1.size() - next1.size();
        if (pref > 0)
        {
            fst1.offset++;
        }
    }

    return stream.str();
}

int main()
{
    int n;
    std::cin >> n;

    std::string last;
    std::cin >> last;

    ull result = 0;
    std::string tmp;

    Ull fst, snd;
    fst.str = std::move(last);

    // std::cout << fst.data()<< std::endl;
    for (int i = 0; i<n-1; ++i)
    {
        std::cin >> tmp;
        snd.str = std::move(tmp);
        if (compare(fst, snd))
        {
            // std::cout << fst.data()<< std::endl;
            std::string next = getNext(fst, snd);
            result += (next.size()-snd.size());
            result += fst.offset;
            snd.str = std::move(next);
        }
        else
        {
            fst.allAlpha = false;
            fst.offset = 0;
        }
        fst.str = std::move(snd.str);
        // std::cout << fst.data()<< std::endl;

        // std::cout << i << std::endl;
        // std::cout << tmp << std::endl;
    }

    std::cout << result << std::endl;

    return 0;
}