#define NDEBUG
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <queue>
#include <string>
#include <vector>
#include <unistd.h>
using namespace std;
#define TRACE(x) cerr<<"# "#x<<endl;
#define DEBUG(x) cerr<<#x<<" = "<<(x)<<endl;
typedef unsigned long long ULL;
typedef long long LL;
const int INF = 0x7FFFFFFF;

class IO {
        #define IO_DEBUG_ENABLED 0
    public:
        IO() {
            buffer = new char[ BUFFER_SIZE ];
            bufferOut = new char[ BUFFER_SIZE ];
        }
        ~IO() {
            /* delete [] buffer; */
            flush();
        }
        inline void readChar(char * const c) {
            readIntoBuffer();
            *c = buffer[ bufferIndex ];
            ++bufferIndex;
        }
        void readUInt(unsigned int * const out) {
            unsigned int res = 0;
            char c;
            skipWC();
            readChar(&c);
            while( (c >= '0') && (c <= '9') ) {
                res *= 10;
                res += c - '0';
                readChar(&c);
            }
            *out = res;
        }
        void readULL(unsigned long long * const out) {
            unsigned long long res = 0;
            char c;
            skipWC();
            readChar(&c);
            while( (c >= '0') && (c <= '9') ) {
                res *= 10;
                res += c - '0';
                readChar(&c);
            }
            *out = res;
        }
        void readInt(int * const out) {
            int res = 0;
                int neg = 0;
            char c;
            skipWC();
            readChar(&c);
            if(c == '-') {
                neg = 1;
                c = '0';
            }
            #if IO_DEBUG_ENABLED
            else if( (c >= '0') && (c <= '9') ) {
            } else {
                fprintf(stderr, "readInt() ERROR unexpected char '%c' (decimal %d)\n", c, static_cast<int>(c));
            }
            #endif
            while( (c >= '0') && (c <= '9') ) {
                res *= 10;
                res += c - '0';
                readChar(&c);
            }
            *out = (0 == neg) ? res : -res;
        }
        void readLL(long long * const out) {
            long long res = 0;
                int neg = 0;
            char c;
            skipWC();
            readChar(&c);
            if(c == '-') {
                neg = 1;
                c = '0';
            }
            #if IO_DEBUG_ENABLED
            else if( (c >= '0') && (c <= '9') ) {
            } else {
                fprintf(stderr, "readLL() ERROR unexpected char '%c' (decimal %d)\n", c, static_cast<int>(c));
            }
            #endif
            while( (c >= '0') && (c <= '9') ) {
                res *= 10;
                res += c - '0';
                readChar(&c);
            }
            *out = (0 == neg) ? res : -res;
        }
        void readLine(char * const dst) {
            char c;
            char *d = dst;
            readChar(&c);
            while(c > 13) { // while((c!=10) && (c!=13) && (c!=0))
                *d = c;
                ++d;
                readChar(&c);
            }
            if(c == 13) { // skip (forget) EOL characters
                readChar(&c);
                if(c != 10) {
                    --bufferIndex; // next char after '/r' is not '/n' - it is unexpected but try to accept as valid EOL
                    #if IO_DEBUG_ENABLED
                    fprintf(stderr, __FUNCTION__ "() ERROR unexpected char (ASCII 0x%x) (decimal %d)\n", static_cast<int>(c), static_cast<int>(c));
                    #endif
                }
            }
            *d = 0;
        }
        char* readString(char * const dst) {
            char c;
            char *d = dst;
            skipWC();
            readChar(&c);
            while((c > 13) && (c != ' ')) {	// Read only "printable" characters
                *d = c;
                ++d;
                readChar(&c);
            }
            *d = 0;
            return d;
        }
        void readString(char * const dst, bool * const isNextCharEOL) {
            readString(dst);
            char c = buffer[bufferIndex-1];
            if((c != 10) && (c != 13) && (c != 0))
                *isNextCharEOL = false;
            else
                *isNextCharEOL = true;
        }
        inline void flush() {
            if(bufferOutIndex > 0) {
                write(1, bufferOut, bufferOutIndex);
                bufferOutIndex = 0;
            }
        }
        inline void writeChar(char c) {
            if(bufferOutIndex >= BUFFER_SIZE) {
                flush();
            }
            bufferOut[ bufferOutIndex++ ] = c;
        }
        inline void writeString(const char *str) {
            for(const char *src = str; *src ;++src) {
                writeChar(*src);
            }
        }

        inline void writeU32(unsigned x) {
            char lbuf[10];
            if((bufferOutIndex+sizeof(lbuf)) >= BUFFER_SIZE) {
                flush();
            }
            if(x) {
                unsigned len=0;
                while(x) {
                    unsigned d = x / 10;
                    lbuf[ ++len ] = '0' + static_cast<char>(x - 10*d);
                    x = d;
                }
                while(len) {
                    bufferOut[ bufferOutIndex++ ] = lbuf[ len-- ];
                }
            } else {
                bufferOut[ bufferOutIndex++ ] = '0';
            }
        }

        inline void writeU64(ULL x) {
            char lbuf[20];
            if((bufferOutIndex+sizeof(lbuf)) >= BUFFER_SIZE) {
                flush();
            }
            if(x) {
                unsigned len=0;
                while(x) {
                    ULL d = x / 10ULL;
                    lbuf[ ++len ] = '0' + static_cast<char>(x - 10ULL*d);
                    x = d;
                }
                while(len) {
                    bufferOut[ bufferOutIndex++ ] = lbuf[ len-- ];
                }
            } else {
                bufferOut[ bufferOutIndex++ ] = '0';
            }
        }

    protected:
        inline void readIntoBuffer() {
            if(bufferIndex >= bytesRead) {
                buffer[0] = 0; // make the first characted white-char => readChar() does not check bytesRead
                bytesRead = read(0, buffer, BUFFER_SIZE);
                bufferIndex = 0;
            }
        }
        inline void skipWC() {
            char *cPtr;
            do {
                readIntoBuffer();
                cPtr = buffer + bufferIndex;
                while( (bufferIndex < bytesRead) && ((*cPtr == 10) || (*cPtr == ' ') || (*cPtr == 13))) {
                    ++bufferIndex;
                    ++cPtr;
                }
            } while((bufferIndex >= bytesRead) && (bytesRead > 0));
        }
    private:
        const unsigned int BUFFER_SIZE = 4 * 1024;
        char *buffer = nullptr;
        int bufferIndex = 0;
        int bytesRead = 0;
        char *bufferOut = nullptr;
        unsigned int bufferOutIndex = 0;
} static io;




constexpr unsigned MAX_LEN = 24;


inline void mycopy(char dst[MAX_LEN], const char src[MAX_LEN] )

{
    static_assert (MAX_LEN==24, "invalid len");
    ULL *d = reinterpret_cast<ULL*>(dst);
    const ULL *s = reinterpret_cast<const ULL*>(src);
    *d = *s;
    *(d+1) = *(s+1);
    *(d+2) = *(s+2);
}

inline unsigned calc(char min[MAX_LEN], unsigned &len, char a[MAX_LEN], const unsigned a_len )
{
        unsigned res = 0;

        if(a_len <= len)
        {
                int greater;
                unsigned i;

                for(i=0; i<a_len; ++i)
                {
                        greater = a[i] - min[i];
                        if(greater) {
                                break;
                        }
                }

//                if(greater > 0) {
                if(greater)
                {
                    len += (static_cast<unsigned>(greater) & 0x80000000)>>31; //if(greater<0) ++len;

                    for(i=a_len; i<MAX_LEN/*len*/; ++i) {
                            a[i] = '0';
                    }
                    res = len - a_len;
                }
                else
                {
                        if(a_len != len)
                        {
                                if(len < MAX_LEN)
                                {
                                        res = len - a_len;
                                        unsigned last = len - 1;
                                        if(min[last] != '9') {
                                            for(i=a_len; i<last; ++i) {
                                                    a[i] = min[i];
                                            }
                                            a[last] = min[last] + 1;
                                        } else {
                                            ++res;
                                            ++len;
                                            for(i=a_len; i<len; ++i) {
                                                    a[i] = '0';
                                            }

                                            for(i=len-3; i>=a_len; --i)
                                            {
                                                if(min[i] != '9')
                                                {
                                                    --res;
                                                    --len;
                                                    for(unsigned k=a_len; k<i; ++k) a[k] = min[k];
                                                    a[i] = min[i] + 1;
                                                    break;
                                                }
                                            }
                                        }
                                }
                                else
                                {
                                        res = len - a_len;
                                        for(i=a_len; i<MAX_LEN; ++i) {
                                                a[i] = min[i];
                                        }
                                }
                        }
                        else
                        {
                                a[len] = '0';
                                ++len;
                                ++res;
                        }
                }
        }
        else
        {
                len = a_len;
        }

    mycopy(min, a);
    return res;
}



int main()
{
    char a[MAX_LEN];
    char min[MAX_LEN] = {};
    unsigned len = 1;
    ULL result = 0ULL;
    unsigned N;

    io.readUInt(&N);

    for(unsigned i=0; i<N; ++i)
    {
        const unsigned a_len = static_cast<unsigned>(io.readString(a) - a);
        result += calc(min, len, a, a_len);

        //if(len<MAX_LEN) {min[len]=0;fprintf (stderr, "%s\n",min);}
    }

    io.writeU64(result);
    io.writeChar('\n');
}