output_description: Print the sum of the evaluated value over all possible formulas.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      S
attempt: from copy import *
  from sys import *
  import math
  import queue
  from collections import defaultdict, Counter, deque
  from fractions import Fraction as frac
  
  setrecursionlimit(1000000)
  
  
  # dp[i][j]: iまでからj枚えらんで和がkになるのは何通り
  def main():
      s = input()
      ans = 0
      for i in range(0, 2 ** (len(s) - 1)):
          temp = []
          ix2 = base_10_to_n(i, 2)
          for i in range(len(s) - len(ix2) - 1):
              ix2 = "0" + ix2
          tmp = s[0]
          for j in range(len(ix2)):
              if ix2[j] == "1":
                  temp.append(tmp)
                  tmp = s[j + 1]
              else:
                  tmp = tmp + s[j + 1]
          temp.append(tmp)
          for i in temp:
              ans += int(i)
      print(ans)
  
  
  def zip(a):
      mae = a[0]
      ziparray = [mae]
      for i in range(1, len(a)):
          if mae != a[i]:
              ziparray.append(a[i])
              mae = a[i]
      return ziparray
  
  
  def is_prime(n):
      if n < 2:
          return False
  
      for k in range(2, int(math.sqrt(n)) + 1):
          if n % k == 0:
              return False
  
      return True
  
  
  def list_replace(n, f, t):
      return [t if i == f else i for i in n]
  
  
  def base_10_to_n(X, n):
      X_dumy = X
      out = ""
      while X_dumy > 0:
          out = str(X_dumy % n) + out
          X_dumy = int(X_dumy / n)
      if out == "":
          return "0"
      return out
  
  
  def gcd(m, n):
      x = max(m, n)
      y = min(m, n)
      while x % y != 0:
          z = x % y
          x = y
          y = z
      return y
  
  
  class queue:
      def __init__(self):
          self.q = deque([])
  
      def push(self, i):
          self.q.append(i)
  
      def pop(self):
          return self.q.popleft()
  
      def size(self):
          return len(self.q)
  
      def debug(self):
          return self.q
  
  
  class stack:
      def __init__(self):
          self.q = []
  
      def push(self, i):
          self.q.append(i)
  
      def pop(self):
          return self.q.pop()
  
      def size(self):
          return len(self.q)
  
      def debug(self):
          return self.q
  
  
  class graph:
      def __init__(self):
          self.graph = defaultdict(list)
  
      def addnode(self, l):
          f, t = l[0], l[1]
          self.graph[f].append(t)
          self.graph[t].append(f)
  
      def rmnode(self, l):
          f, t = l[0], l[1]
          self.graph[f].remove(t)
          self.graph[t].remove(f)
  
      def linked(self, f):
          return self.graph[f]
  
  
  class dgraph:
      def __init__(self):
          self.graph = defaultdict(set)
  
      def addnode(self, l):
          f, t = l[0], l[1]
          self.graph[f].append(t)
  
      def rmnode(self, l):
          f, t = l[0], l[1]
          self.graph[f].remove(t)
  
      def linked(self, f):
          return self.graph[f]
  
  
  main()
  
problem_description: Statement
  
  You are given a string S consisting of digits between `1` and `9`, inclusive.
  You can insert the letter `+` into some of the positions (possibly none)
  between two letters in this string. Here, `+` must not occur consecutively
  after insertion.
  
  All strings that can be obtained in this way can be evaluated as formulas.
  
  Evaluate all possible formulas, and print the sum of the results.
samples: [{"input": "125", "output": "176\n    \n\nThere are 4 formulas that can be obtained: `125`, `1+25`, `12+5` and `1+2+5`.\nWhen each formula is evaluated,\n\n  * 125\n  * 1+25=26\n  * 12+5=17\n  * 1+2+5=8\n\nThus, the sum is 125+26+17+8=176.\n\n* * *"}, {"input": "9999999999", "output": "12656242944"}]