
#include <iostream>
#include <stdio.h>
#include <vector>
#include <map>
#include <stack>
#include <cstring>
#include <utility>
#include <iostream>
#include <iomanip>
#include <list>
#include <queue>
#include <algorithm>
#include <cmath>
#include <set>
#include <unordered_set>
#include <bitset>
#define FOR(i,a,b) for (ll i=(a);i<(ll)(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define SUM(v) accumulate(ALL(v),0ll)
using ll = long long;
const ll INF=1000000;
using namespace std;
const ll mod=1000000007;
int main()
{
	ll n;
	cin>>n;
	ll x=1000;
	ll ans=0;

	while(true)
	{
		if(n<x)
		{
			break;
		}
		ans+=n-x+1;
		x*=1000;
	}
	cout<<ans<<endl;
	return 0;   
}
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
    if (b == 0) {
        return a;
    } else {
        return gcd(b, a % b);
    }
}
long long gcd_vec(vector<long long> const &A) { // N個の要素に対する最大公約数
    int size = (int)A.size();
    long long ret = A[0];
    for (int i = 1; i < size; i++) {
        ret = gcd(ret, A[i]);
    }
    return ret;
}
long long lcm2(long long a, long long b) {
    long long d = gcd(a, b);
    return a / d * b;
}
long long lcm(const vector<long long> &vec) {
    long long l = vec[0];
    for (int i = 0; i < vec.size() - 1; i++) {
        l = lcm2(l, vec[i + 1]);
    }
    return l;
}
long long int mypow(long long int a,long long int b){
    long long int i=0,ans;
    for(i=0;i<b;i++)
    {
        if(i==0)
        {
            ans=a;
        }
        else
        {
            ans*=a;
        }
    }
    return ans;   
}
struct UnionFind{
    int n;
    vector<int> par; // 親の番号
    vector<int> siz; // サイズを表している。

    // 初期化する。parは自身を指す（iotaは 0 ~ nまでの数字を順に入れていく）
    // size(siz) は最初はすべて１
    UnionFind(int n) : n(n){
        par.resize(n);
        iota(par.begin(),par.end(),0);
        siz.assign(n,1);
    }

    // 頂点の親を求める。
    // 再帰関数を使っており、経路圧縮もしている。
    int root(int x){
        // ここは親の処理。
        if (par[x] == x){
            return x;
        }

        //経路圧縮をしながら値を返す。
        // par[x] = root(par[x]);
        // return par[x];
        // と同じ意味。
        return par[x] = root(par[x]);
    }

    // unite :: a と bを同じグループに入れる。
    // もし初めから同じなら何もしない。
    void unite(int a,int b){
        int ra = root(a);
        int rb = root(b);

        if(ra == rb){
            return;
        }

        // サイズの大きい方にサイズの小さいほうを合成するので、swapしている。
        if (siz[ra] < siz[rb]){
            swap(ra,rb);
        }
        // サイズが大きい方に小さいのを合体
        // 小さいほうの親は大きい方の親になる。
        siz[ra] += siz[rb];
        par[rb] = ra;
    }

    //　同じグループかどうか判定するには、親が一緒かどうかをみたらよい
    bool same(int x,int y){
        return root(x) == root(y);
    }

    // 頂点が含まれるグループの頂点を求める。
    int get_size(int x){
        return siz[root(x)];
    }
};
    long long int facctorialMethod(int k){
    long long int sum = 1;
    for (int i = 1; i <= k; ++i)
    {
        sum *= i;
    }
    return sum;
}
#define PI 3.14159265359
int main()
{
	[[maybe_unused]]long long int i=0,j=0,a,b,w,g,c=0,c1=0,c2,c3,c4,n;
    [[maybe_unused]]double qw;
    string s,s1;
    cin >> n;
        c+=1000000-1000;
        c1=c;
        c+=2*(1000000000-1000000);
        c2=c;
        c+=3*(1000000000000-1000000000);
        c3=c;
        c+=4*(1000000000000000-1000000000000);
        c4=c;
    if(n<1000)
    {
        cout << "0";
    }
    else if(n<1000000)
    {
        cout << n-999;
    }
    else if(n<1000000000)
    {
        cout << c1+(n-999999)*2;
    }
    else if(n<1000000000000)
    {
        cout << c2+(n-999999999)*3;
    }
    else if(n<1000000000000000)
    {
        cout << c3+(n-999999999999)*4;
    }
    else
    {
        cout << c3+(n-999999999999-1)*4+5;
    }
    return 0;
}