output_description: Print the eventual length of X.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      X
attempt: # root.search(x): ◯.data == x のものが存在するある場合それを出力、ない場合Noneを出力
  # root.insert(x): ◯.data == xが存在する場合Falseを出力、ない場合◯.data == x なる頂点を作る
  # y.to_s(): 頂点yのdataを出力
  # y.left_s(): 頂点yのleftを出力(ない場合はNone)
  # root.search_lower(x,None): ○.dataがxより小さいものの中で最も大きいものを出力、ない場合Noneを出力
  # root.search_higher(x,None): xより大きいものの中で最も小さいものを出力、ない場合Noneを出力
  
  
  ################################################################################
  class Avltree:
      def __init__(self, key=None):
          self.key = key
          self.left = None
          self.right = None
          self.balance = "Even"
  
      def search_lower(self, key, key_lower):
          if self.key == None:
              return key_lower
          if self.key > key:
              if self.left == None:
                  return key_lower
              else:
                  return self.left.search_lower(key, key_lower)
          if self.key < key:
              key_lower = self.key
              if self.right == None:
                  return key_lower
              else:
                  return self.right.search_lower(key, key_lower)
          # self.key == keyの場合
          if self.left == None:
              return key_lower
          else:
              if key_lower == None:
                  return self.left.end_higher(self.left.key)
              else:
                  return max(key_lower, self.left.end_higher(self.left.key))
  
      def search_higher(self, key, key_higher):
          if self.key == None:
              return key_higher
          if self.key > key:
              key_higher = self.key
              if self.left == None:
                  return key_higher
              else:
                  return self.left.search_higher(key, key_higher)
          if self.key < key:
              if self.right == None:
                  return key_higher
              else:
                  return self.right.search_higher(key, key_higher)
          # self.key == keyの場合
          if self.right == None:
              return key_higher
          else:
              if key_higher == None:
                  return self.right.end_lower(self.right.key)
              else:
                  return min(key_higher, self.right.end_lower(self.right.key))
  
      def end_lower(self, end_lower_key):
          if self.left == None:
              return end_lower_key
          else:
              end_lower_key = self.left.key
              return self.left.end_lower(end_lower_key)
  
      def end_higher(self, end_higher_key):
          if self.right == None:
              return end_higher_key
          else:
              end_higher_key = self.right.key
              return self.right.end_higher(end_higher_key)
  
      def DoubleRightRotation(self):
          tl = self.left
          self.left = tl.right.right
          tl.right.right = self  # selfはそのノード
          tlr = tl.right
          tl.right = tlr.left
          tlr.left = tl
          if tlr.balance == "Left":
              tlr.right.balance = "Right"
              tlr.left.balance = "Even"
          elif tlr.balance == "Right":
              tlr.right.balance = "Even"
              tlr.left.balance = "Left"
          elif tlr.balance == "Even":
              tlr.right.balance = "Even"
              tlr.left.balance = "Even"
          tlr.balance = "Even"
          return tlr
  
      def DoubleLeftRotation(self):
          tr = self.right
          self.right = tr.left.left
          tr.left.left = self
          trl = tr.left
          tr.left = trl.right
          trl.right = tr
          if trl.balance == "Right":
              trl.left.balance = "Left"
              trl.right.balance = "Even"
          elif trl.balance == "Left":
              trl.left.balance = "Even"
              trl.right.balance = "Right"
          elif trl.balance == "Even":
              trl.left.balance = "Even"
              trl.right.balance = "Even"
          trl.balance = "Even"
          return trl
  
      def SingleLeftRotation(self):
          tr = self.right
          tr.balance = "Even"
          self.balance = "Even"
          self.right = tr.left
          tr.left = self
          return tr
  
      def SingleRightRotation(self):
          tl = self.left
          tl.balance = "Even"
          self.balance = "Even"
          self.left = tl.right
          tl.right = self
          return tl
  
      def replace(self, p, v):  # 親ノードpの下にある自分(self)をvに置き換える。
          if p.left == self:
              p.left = v
          else:
              p.right = v
  
      def insert(self, key):  # rootでのみ呼ばれる挿入
          if self.key == None:  # rootを含むrotationはしないことにする。
              self.key = key
              return self
          if key < self.key:
              if self.left == None:
                  self.left = Avltree(key)
              else:
                  self.left.insertx(self, key)
          elif key > self.key:
              if self.right == None:
                  self.right = Avltree(key)
              else:
                  self.right.insertx(self, key)
          else:  # key == self.key:
              pass  # do not overwrite
  
      def insertx(self, p, key):  # replaceを呼ぶために一つ上の親を持っているinsert
          if self.key > key:
              if self.left == None:
                  self.left = Avltree(key)
              else:
                  if not self.left.insertx(self, key):  # 左の木が生長しなければ、
                      return False  # 成長しない
              if self.balance == "Right":
                  self.balance = "Even"
                  return False
              elif self.balance == "Even":
                  self.balance = "Left"
                  return True  # 成長した
              elif self.balance == "Left":
                  if self.left.balance == "Right":
                      self.replace(p, self.DoubleRightRotation())
                  elif self.left.balance == "Left":
                      self.replace(p, self.SingleRightRotation())
                  return False  # rotationを行うと成長しない
          if self.key < key:
              if self.right == None:
                  self.right = Avltree(key)
              else:
                  if not self.right.insertx(self, key):
                      return False
              if self.balance == "Left":
                  self.balance = "Even"
                  return False
              elif self.balance == "Even":
                  self.balance = "Right"
                  return True
              elif self.balance == "Right":
                  if self.right.balance == "Left":
                      self.replace(p, self.DoubleLeftRotation())
                  elif self.right.balance == "Right":
                      self.replace(p, self.SingleLeftRotation())
                  return False
          return False  # self.key == keyの時は何もしないので成長もしない
  
  
  ################################################################
  
  
  def inpl():
      return [int(i) for i in input().split()]
  
  
  n = int(input())
  a = inpl()
  b = {a[i]: i for i in range(n)}
  
  root = Avltree()
  ass = 0
  
  for i in range(1, n + 1):
      l = root.search_lower(b[i], None)
      r = root.search_higher(b[i], None)
      if l == None:
          l = -1
      if r == None:
          r = n
      ass += (b[i] - l) * (r - b[i]) * i
      root.insert(b[i])
  print(0)
  
problem_description: Statement
  
  We have a string X, which has an even number of characters. Half the
  characters are `S`, and the other half are `T`.
  
  Takahashi, who hates the string `ST`, will perform the following operation
  10^{10000} times:
  
    * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing.
  
  Find the eventual length of X.
samples: [{"input": "TSTTSS", "output": "4\n    \n\nIn the 1-st operation, the 2-nd and 3-rd characters of `TSTTSS` are removed. X\nbecomes `TTSS`, and since it does not contain `ST` anymore, nothing is done in\nthe remaining 10^{10000}-1 operations. Thus, the answer is 4.\n\n* * *"}, {"input": "SSTTST", "output": "0\n    \n\nX will eventually become an empty string: `SSTTST` \u21d2 `STST` \u21d2 `ST` \u21d2 ``.\n\n* * *"}, {"input": "TSSTTTSS", "output": "4\n    \n\nX will become: `TSSTTTSS` \u21d2 `TSTTSS` \u21d2 `TTSS`."}]