#include <iostream>
#include <vector>
#include<algorithm>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include<iomanip>
#include<bitset>
#include<numeric>
#include<queue>
using namespace std;
#define rep(i,a,b) for (int i = (a); i < (int)(b); ++i)
#define endl "\n"
typedef long long ll;
typedef string str;
typedef pair<int, int> P;
const double pi = 3.14159265358979323846;
const int inf = (1 << 20);
const int dx[8] = { 1, 0, -1, 0, 1, -1, -1, 1 };
const int dy[8] = { 0, 1, 0, -1, 1, 1, -1, -1 };

int ctoi(const char c) {
    if ('0' <= c && c <= '9') return (c - '0');
    return -1;
}
vector<int> input(int n) {
    vector<int> vec(n);
    for (int i = 0; i < n; i++) {
        cin >> vec.at(i);
    }
    return vec;
}
void output(vector<vector<int>> table) {
    for (int i = 0; i < table.size(); i++) {
        for (int j = 0; j < table.at(0).size(); j++) {
            cout << table.at(i).at(j) << " ";
        }
        cout << endl;
    }
}
long long perm(int n, int r) {
    if (n < r) {
        cout << "error" << endl;
        return 0;
    }
    long long perm = 1;
    for (int i = n; i > n - r; i--) {
        perm *= i;
    }
    return perm;
}
long long comb(int n, int r) {
    if (n < r) {
        cout << "error" << endl;
        return 0;
    }
    long long comb = perm(n, r);
    for (int i = r; i > 0; i--) {
        comb /= i;
    }
    return comb;
}
long long fact(int n) {
    long long fact = 1;
    for (int i = n; i > 0; i--) {
        fact *= i;
    }
    return fact;
}
int gcd(int a, int b) {

    if (a % b == 0) {
        return(b);
    }
    else {
        return(gcd(b, a % b));
    }
}
int lcm(int a, int b) {
    return a * b / gcd(a, b);
}
bool isprime(int n) {
    if (n < 2) return false;
    else if (n == 2) return true;
    else if (n % 2 == 0) return false;

    for (int i = 3; i*i <= n; i += 2) {
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}
//約数列挙
vector<long long> divisors(long long N) {
    vector<long long> res;
    for (long long i = 1; i * i <= N; ++i) {
        if (N % i == 0) {
            res.push_back(i);
            // 重複しないならば i の相方である N/i も push
            if (N / i != i) res.push_back(N / i);
        }
    }
    // 小さい順に並び替える
    sort(res.begin(), res.end());
    return res;

    /*long long N;
    cin >> N;
    vector<long long> res = divisors(N);
    for (int i = 0; i < res.size(); ++i) {
        cout << res[i] << " ";
    }
    cout << endl;*/
}
//n以下の素数列挙
vector<long long> eratosthenes(long long n) {
    vector<bool> isprime(n + 1, true);
    vector<long long> prime;
    isprime[0] = isprime[1] = false;
    for (int i = 2; i <= n; i++) {
        if (isprime[i]) {
            for (int j = 2 * i; j <= n; j += i) {
                isprime[j] = false;
            }
            prime.emplace_back(i);
        }
    }
    return prime;
}
//素因数分解の前計算(その数を割り切る最小の素数の配列)
vector<long long> sieve(long long n) {
    vector<long long> res(n);
    iota(res.begin(), res.end(), 0);
    for (ll i = 2; i * i < n; i++) {
        if (res[i] < i) continue;
        for (ll j = i * i; j < n; j += i) {
            if (res[j] == j)res[j] = i;
        }
    }
    return res;
}
//素因数分解
vector<pair<long long, long long>> factor(long long n) {
    vector<long long> d = sieve(n + 1);
    vector<pair<ll, ll>> factor;
    while (!isprime(n)) {
        ll ex = 0, a;
        a = d[n];
        while (n % a == 0) {
            ex++;
            n /= a;
        }
        factor.push_back({ a,ex });
    }
    if (n != 1) {
        factor.push_back({ n,1 });
    }
    return factor;
}
long long fib(long long n) {
    long long x, y, t;
    if (n == 1) {
        return 0;
    }
    else if (n == 2) {
        return 1;
    }
    else {
        x = 0;
        y = 1;
        for (int i = 3; i < n; ++i) {
            t = y;
            y += x;
            x = t;
        }
        return x + y;
    }
}
void Yes(bool f) {
    if (f) {
        cout << "Yes" << endl;
    }
    else {
        cout << "No" << endl;
    }
}
void YES(bool f) {
    if (f) {
        cout << "YES" << endl;
    }
    else {
        cout << "NO" << endl;
    }
}
inline void InitRand()
{
    srand((unsigned int)time(NULL));
}
double determinant(int n, vector<vector<double>> a) {
    double det = 1;
    double buf;
    int i, j, k;
    bool flagerror = true;
    for (i = 0; i < n; ++i) {
        if (a[i][0] != 0) {
            flagerror = false;
        }
    }
    if (flagerror) {
        return 0;
    }
    //(0,0)が0の時のエラーを回避
    if (a[0][0] == 0) {
        for (int i = 1; i < n;++i) {
            if (a[i][0] != 0) {
                for (int j = 0; j < n; ++j) {
                    int x = a[0][j];
                    a[0][j] = a[i][j];
                    a[i][j] = x;
                }
                det = -1;
                break;
            }
        }
    }
    //三角行列を作成
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            if (i < j) {
                buf = a[j][i] / a[i][i];
                for (k = 0; k < n; k++) {
                    a[j][k] -= a[i][k] * buf;
                }
            }
        }
    }

    //対角部分の積
    for (i = 0; i < n; i++) {
        det *= a[i][i];
    }
    return det;
}
vector<vector<double>> inversematrix(int n, vector<vector<double>> a) {
    vector<vector<double>> inv_a(n,vector<double>(n)); //ここに逆行列が入る
    double buf; //一時的なデータを蓄える
    int i, j, k; //カウンタ

    //a(0,0)が0の時のエラーを回避
    bool flag = false;
    int f;
    if (a[0][0] == 0) {
        for (i = 1; i < n; ++i) {
            if (a[i][0] != 0) {
                for (j = 0; j < n; ++j) {
                    int x = a[0][j];
                    a[0][j] = a[i][j];
                    a[i][j] = x;
                }
                f = i;
                flag = true;
                break;
            }
        }
    }

    //単位行列を作る
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            inv_a[i][j] = (i == j) ? 1.0 : 0.0;
        }
    }
    //a(0,0)が0の時単位行列の入替
    if (flag) {
        inv_a[f][0] = 1;
        inv_a[f][f] = 0;
        inv_a[0][f] = 1;
        inv_a[0][0] = 0;
    }
    //掃き出し法
    for (i = 0; i < n; i++) {
        buf = 1 / a[i][i];
        for (j = 0; j < n; j++) {
            a[i][j] *= buf;
            inv_a[i][j] *= buf;
        }
        for (j = 0; j < n; j++) {
            if (i != j) {
                buf = a[j][i];
                for (k = 0; k < n; k++) {
                    a[j][k] -= a[i][k] * buf;
                    inv_a[j][k] -= inv_a[i][k] * buf;
                }
            }
        }
    }
    return inv_a;
}
bitset<50> intersection(bitset<50> A, bitset<50> B){// AとBに共通して含まれる要素からなる集合を返す 
    return A & B;
}
bitset<50> union_set(bitset<50> A, bitset<50> B) {// AとBのうち少なくとも一方に含まれる要素からなる集合を返す
    return A | B;
    
}
bitset<50> symmetric_diff(bitset<50> A, bitset<50> B) {// AとBのうちどちらか一方にだけ含まれる要素からなる集合を返す
    return  A ^ B;
}
bitset<50> subtract(bitset<50> A, int x) {// Aから値xを除く
    return A.reset(x);
}
bitset<50> increment(bitset<50> A) {// Aに含まれる要素に1を加える(ただし、要素49が含まれる場合は0になるものとする)
    bitset<50> ret = A << 1;
    if (A.test(49)) {
        ret.set(0);
    }
    return ret;
}
bitset<50> decrement(bitset<50> A) {// Aに含まれる要素から1を引く(ただし、要素0が含まれる場合は49になるものとする)
    bitset<50> ret = A >> 1;
    if (A.test(0)) {
        ret.set(49);
    }
    return ret;
}
bitset<50> add(bitset<50> S, int x) {// Sに値xを加える
    S.set(x, 1);  // xビット目を1にする
    return S;
}
void print_set(bitset<20> S) {// 集合Sの内容を昇順で出力する(スペース区切りで各要素の値を出力する)
    vector<int> cont;
    for (int i = 0; i < 20; i++) {
        if (S.test(i)) {
            cont.push_back(i);
        }
    }
    for (int i = 0; i < cont.size(); i++) {
        if (i > 0) cout << " ";
        cout << cont.at(i);
    }
    cout << endl;
}
bool in(vector<int> a, int x) {
    if (find(a.begin(), a.end(), x) != a.end()) {
        return true;
    }
    else {
        return false;
    }
}
int count_bool(vector<bool> flag) {
    int count = 0;
    for (int i = 0; i<int(flag.size()); i++) {
        if (flag[i]) {
            count++;
        }
    }
    return count;
}
template<class T> inline bool chmin(T& a, T b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}
template<class T> inline bool chmax(T& a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}
int vecgcd(vector<long long> a) {
    ll n = a.size();
    for (int i = n - 2; i >= 0; i--) {
        a[i] = gcd(a[i], a[i + 1]);
    }
    return a.front();
}
int main() {
    str s;
    cin >> s;
    int n = s.size()-1;
    ll ans = 0;
    for (int tmp = 0; tmp < (1 << n); tmp++) {
        bitset<10> b(tmp);
        str t = "";
        for (int i = 0; i < n; i++) {
            t += s[i];
            if (b.test(i)) {
                t += '+';
            }
        }
        t += s[n];
        ll a = 0;
        for (int i = 0; i < t.size(); i++) {
            if (t[i] != '+') {
                a *= 10;
                a += ctoi(t[i]);
            }
            else {
                ans += a;
                a = 0;
            }

            if (i == t.size() - 1) {
                ans += a;
            }
        }
    }
    cout << ans << endl;
}

Measured memory_bytes: 3572