output_description: Print the maximum possible that a train can cover in the run.  
  Output is considered correct if its absolute difference from the judge's
  output is at most 10^{-3}.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      t_1 t_2 t_3 … t_N
      v_1 v_2 v_3 … v_N
attempt: class ConvexHullTrick:
      def __init__(self, xlist, INF=10**18):
          xlist = sorted(xlist)
          self.comp = {x: k for k, x in enumerate(xlist)}
          self.h = (len(xlist) - 1).bit_length()
          self.n = 2**self.h
          self.ie = (0, INF)
          self.inf = INF
          self.x = xlist + [INF] * (self.n - len(xlist))
          self.tree = [self.ie for _ in range(2 * self.n)]
  
      def val(self, line, x):
          a, b = line
          return a * x + b
  
      def _add_(self, line, idx, lt, rt):
          while True:
              mid = (lt + rt) // 2
              lx = self.x[lt]
              mx = self.x[mid]
              rx = self.x[rt - 1]
              lu = self.val(line, lx) < self.val(self.tree[idx], lx)
              mu = self.val(line, mx) < self.val(self.tree[idx], mx)
              ru = self.val(line, rx) < self.val(self.tree[idx], rx)
              if lu and ru:
                  self.tree[idx] = line
                  return
              if not lu and not ru:
                  return
              if mu:
                  self.tree[idx], line = line, self.tree[idx]
              if lu != mu:
                  rt = mid
                  idx = 2 * idx
              else:
                  lt = mid
                  idx = 2 * idx + 1
  
      def add_line(self, line):
          self._add_(line, 1, 0, self.n)
  
      def add_seg(self, line, lt, rt):
          lidx = self.comp[lt] + self.n
          ridx = self.comp[rt] + self.n
          lt = self.comp[lt]
          rt = self.comp[rt]
          size = 1
          while ridx - lidx > 0:
              if lidx & 1:
                  self._add_(line, lidx, lt, lt + size)
                  lidx += 1
                  lt += size
              if ridx & 1:
                  ridx -= 1
                  rt -= size
                  self._add_(line, ridx, rt, rt + size)
              lidx >>= 1
              ridx >>= 1
              size <<= 1
  
      def get_min(self, x):
          idx = self.comp[x] + self.n
          res = self.inf
          while idx:
              res = min(res, self.val(self.tree[idx], x))
              idx >>= 1
          return res
  
  
  N = int(input())
  T = list(map(int, input().split()))
  V = [0] + list(map(int, input().split())) + [0]
  X = [0]
  
  for i in range(N):
      X.append(X[-1] + 2 * T[i])
  
  cht = ConvexHullTrick(range(X[-1] + 2))
  
  for i in range(N):
      cht.add_seg((0, 2 * V[i + 1]), X[i], X[i + 1] + 1)
  
  for i in range(N):
      cht.add_seg((1, 2 * V[i] - X[i]), X[i], X[-1] + 1)
  
  for i in range(N):
      cht.add_seg((-1, 2 * V[i + 2] + X[i + 1]), X[0], X[i + 1] + 1)
  
  D = [0 for _ in range(X[-1] + 1)]
  
  for i in range(X[-1] + 1):
      D[i] = cht.get_min(i)
  
  S = 0
  
  for i in range(X[-1]):
      S += D[i] * 2 + (D[i + 1] - D[i])
  
  print(S / 8)
  
problem_description: Statement
  
  In the year 2168, AtCoder Inc., which is much larger than now, is starting a
  limited express train service called _AtCoder Express_.
  
  In the plan developed by the president Takahashi, the trains will run as
  follows:
  
    * A train will run for (t_1 + t_2 + t_3 + ... + t_N) seconds.
    * In the first t_1 seconds, a train must run at a speed of at most v_1 m/s (meters per second). Similarly, in the subsequent t_2 seconds, a train must run at a speed of at most v_2 m/s, and so on.
  
  According to the specifications of the trains, the acceleration of a train
  must be always within ±1m/s^2. Additionally, a train must stop at the
  beginning and the end of the run.
  
  Find the maximum possible distance that a train can cover in the run.
samples: [{"input": "1\n    100\n    30", "output": "2100.000000000000000\n    \n\n![ ](https://img.atcoder.jp/abc076/69c1f4241b608bc36f1f08dd4184d3f0.png)\n\nThe maximum distance is achieved when a train runs as follows:\n\n  * In the first 30 seconds, it accelerates at a rate of 1m/s^2, covering 450 meters.\n  * In the subsequent 40 seconds, it maintains the velocity of 30m/s, covering 1200 meters.\n  * In the last 30 seconds, it decelerates at the acceleration of -1m/s^2, covering 450 meters.\n\nThe total distance covered is 450 \\+ 1200 \\+ 450 = 2100 meters.\n\n* * *"}, {"input": "2\n    60 50\n    34 38", "output": "2632.000000000000000\n    \n\n![ ](https://img.atcoder.jp/abc076/a3e07ea723f50df04461165bc2cc8890.png)\n\nThe maximum distance is achieved when a train runs as follows:\n\n  * In the first 34 seconds, it accelerates at a rate of 1m/s^2, covering 578 meters.\n  * In the subsequent 26 seconds, it maintains the velocity of 34m/s, covering 884 meters.\n  * In the subsequent 4 seconds, it accelerates at a rate of 1m/s^2, covering 144 meters.\n  * In the subsequent 8 seconds, it maintains the velocity of 38m/s, covering 304 meters.\n  * In the last 38 seconds, it decelerates at the acceleration of -1m/s^2, covering 722 meters.\n\nThe total distance covered is 578 \\+ 884 \\+ 144 \\+ 304 \\+ 722 = 2632 meters.\n\n* * *"}, {"input": "3\n    12 14 2\n    6 2 7", "output": "76.000000000000000\n    \n\n![ ](https://img.atcoder.jp/abc076/77f821f590cb19d8e449303a102422dc.png)\n\nThe maximum distance is achieved when a train runs as follows:\n\n  * In the first 6 seconds, it accelerates at a rate of 1m/s^2, covering 18 meters.\n  * In the subsequent 2 seconds, it maintains the velocity of 6m/s, covering 12 meters.\n  * In the subsequent 4 seconds, it decelerates at the acceleration of -1m/s^2, covering 16 meters.\n  * In the subsequent 14 seconds, it maintains the velocity of 2m/s, covering 28 meters.\n  * In the last 2 seconds, it decelerates at the acceleration of -1m/s^2, covering 2 meters.\n\nThe total distance covered is 18 \\+ 12 \\+ 16 \\+ 28 \\+ 2 = 76 meters.\n\n* * *"}, {"input": "1\n    9\n    10", "output": "20.250000000000000000\n    \n\n![ ](https://img.atcoder.jp/abc076/ebde8cbeb649ae7fd338180c0562ae0b.png)\n\nThe maximum distance is achieved when a train runs as follows:\n\n  * In the first 4.5 seconds, it accelerates at a rate of 1m/s^2, covering 10.125 meters.\n  * In the last 4.5 seconds, it decelerates at the acceleration of -1m/s^2, covering 10.125 meters.\n\nThe total distance covered is 10.125 \\+ 10.125 = 20.25 meters.\n\n* * *"}, {"input": "10\n    64 55 27 35 76 119 7 18 49 100\n    29 19 31 39 27 48 41 87 55 70", "output": "20291.000000000000"}]