output_description: For each dataset, output a single line containing an integer which is the
  value of the given expression.
input_description: The input consists of multiple datasets. Each dataset starts with a line
  containing a positive integer _n_ , followed by _n_ lines denoting a single
  expression in Dr. Tsukuba's notation.
  
  You may assume that, in the expressions given in the input, every integer
  comprises a single digit and that every expression has no more than nine
  integers. You may also assume that all the input expressions are valid in the
  Dr. Tsukuba's notation. The input contains no extra characters, such as spaces
  or empty lines.
  
  The last dataset is immediately followed by a line with a single zero.
attempt: def calc(p, nums):
      if p == "+":
          ans = sum(nums)
      else:
          ans = 1
          for i in nums:
              ans *= i
      return ans
  
  
  while True:
      n = int(input())
      if n == 0:
          quit()
      w = []
      depth = 0
      for i in range(n):
          t = input()
          td = t.count(".")
          tc = t.replace(".", "")
          if tc.isdigit():
              tc = int(tc)
          else:
              td += 1
          w.append([td, tc])
          depth = max(depth, td)
  
      # while len(w) != 1:
      while depth > 0:
          # print(w)
          for i in range(len(w)):
              if w[i][0] == depth:
                  temp = []
                  for j in range(i + 1, len(w)):
                      # print(w[j][1], j)
                      if w[j][0] == depth and str(w[j][1]).isdigit():
                          temp.append(w[j][1])
                  # print(w[i][1], temp)
                  ta = calc(w[i][1], temp)
                  # print(ta)
                  if j >= len(w):
                      w = w[:i] + [[depth - 1, ta]]
                  else:
                      w = w[:i] + [[depth - 1, ta]] + w[j:]
                  # w = w[:i] + w[depth, ta] + w[j:]
                  break
          depth -= 1
      print(w[0][1])
  
problem_description: ICPC Calculator
  
  In mathematics, we usually specify the order of operations by using
  parentheses. For example, 7 × (3 + 2) always means multiplying 7 by the result
  of 3 + 2 and never means adding 2 to the result of 7 × 3. However, there are
  people who do not like parentheses. International Counter of Parentheses
  Council (ICPC) is attempting to make a notation without parentheses the world
  standard. They are always making studies of such no-parentheses notations.
  
  Dr. Tsukuba, a member of ICPC, invented a new parenthesis-free notation. In
  his notation, a single expression is represented by multiple lines, each of
  which contains an addition operator (+), a multiplication operator (*) or an
  integer. An expression is either a single integer or an operator application
  to _operands._ Integers are denoted in decimal notation in one line. An
  operator application is denoted by a line of its operator immediately followed
  by lines denoting its two or more operands, each of which is an expression,
  recursively. Note that when an operand is an operator application, it
  comprises multiple lines.
  
  As expressions may be arbitrarily nested, we have to make it clear which
  operator is applied to which operands. For that purpose, each of the
  expressions is given its _nesting level._ The top level expression has the
  nesting level of 0. When an expression of level _n_ is an operator
  application, its operands are expressions of level _n_ \+ 1. The first line of
  an expression starts with a sequence of periods (.), the number of which
  indicates the level of the expression.
  
  For example, 2 + 3 in the regular mathematics is denoted as in Figure 1. An
  operator can be applied to two or more operands. Operators + and * represent
  operations of summation of all operands and multiplication of all operands,
  respectively. For example, Figure 2 shows an expression multiplying 2, 3, and
  4. For a more complicated example, an expression (2 + 3 + 4) × 5 in the
  regular mathematics can be expressed as in Figure 3 while (2 + 3) × 4 × 5 can
  be expressed as in Figure 4.
  
      
      
      +
      .2
      .3
      
  
  Figure 1: 2 + 3  
    
  
      
      
      *
      .2
      .3
      .4
      
  
  Figure 2: An expression multiplying 2, 3, and 4  
    
  
      
      
      *
      .+
      ..2
      ..3
      ..4
      .5
      
  
  Figure 3: (2 + 3 + 4) × 5  
    
  
      
      
      *
      .+
      ..2
      ..3
      .4
      .5
      
  
  Figure 4: (2 + 3) × 4 × 5  
    
  
  Your job is to write a program that computes the value of expressions written
  in Dr. Tsukuba's notation to help him.
samples: [{"input": "9\n    4\n    +\n    .1\n    .2\n    .3\n    9\n    +\n    .0\n    .+\n    ..*\n    ...1\n    ...*\n    ....1\n    ....2\n    ..0\n    10\n    +\n    .+\n    ..6\n    ..2\n    .+\n    ..1\n    ..*\n    ...7\n    ...6\n    .3\n    0", "output": "6\n    2\n    54"}]