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: # -*- coding: utf-8 -*-
  
  #############
  # Libraries #
  #############
  
  import sys
  
  input = sys.stdin.readline
  
  import math
  
  # from math import gcd
  import bisect
  import heapq
  from collections import defaultdict
  from collections import deque
  from collections import Counter
  from functools import lru_cache
  
  #############
  # Constants #
  #############
  
  MOD = 10**9 + 7
  INF = float("inf")
  AZ = "abcdefghijklmnopqrstuvwxyz"
  
  #############
  # Functions #
  #############
  
  
  ######INPUT######
  def I():
      return int(input().strip())
  
  
  def S():
      return input().strip()
  
  
  def IL():
      return list(map(int, input().split()))
  
  
  def SL():
      return list(map(str, input().split()))
  
  
  def ILs(n):
      return list(int(input()) for _ in range(n))
  
  
  def SLs(n):
      return list(input().strip() for _ in range(n))
  
  
  def ILL(n):
      return [list(map(int, input().split())) for _ in range(n)]
  
  
  def SLL(n):
      return [list(map(str, input().split())) for _ in range(n)]
  
  
  ######OUTPUT######
  def P(arg):
      print(arg)
      return
  
  
  def Y():
      print("Yes")
      return
  
  
  def N():
      print("No")
      return
  
  
  def E():
      exit()
  
  
  def PE(arg):
      print(arg)
      exit()
  
  
  def YE():
      print("Yes")
      exit()
  
  
  def NE():
      print("No")
      exit()
  
  
  #####Shorten#####
  def DD(arg):
      return defaultdict(arg)
  
  
  #####Inverse#####
  def inv(n):
      return pow(n, MOD - 2, MOD)
  
  
  ######Combination######
  kaijo_memo = []
  
  
  def kaijo(n):
      if len(kaijo_memo) > n:
          return kaijo_memo[n]
      if len(kaijo_memo) == 0:
          kaijo_memo.append(1)
      while len(kaijo_memo) <= n:
          kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
      return kaijo_memo[n]
  
  
  gyaku_kaijo_memo = []
  
  
  def gyaku_kaijo(n):
      if len(gyaku_kaijo_memo) > n:
          return gyaku_kaijo_memo[n]
      if len(gyaku_kaijo_memo) == 0:
          gyaku_kaijo_memo.append(1)
      while len(gyaku_kaijo_memo) <= n:
          gyaku_kaijo_memo.append(
              gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo), MOD - 2, MOD) % MOD
          )
      return gyaku_kaijo_memo[n]
  
  
  def nCr(n, r):
      if n == r:
          return 1
      if n < r or r < 0:
          return 0
      ret = 1
      ret = ret * kaijo(n) % MOD
      ret = ret * gyaku_kaijo(r) % MOD
      ret = ret * gyaku_kaijo(n - r) % MOD
      return ret
  
  
  ######Factorization######
  def factorization(n):
      arr = []
      temp = n
      for i in range(2, int(-(-(n**0.5) // 1)) + 1):
          if temp % i == 0:
              cnt = 0
              while temp % i == 0:
                  cnt += 1
                  temp //= i
              arr.append([i, cnt])
      if temp != 1:
          arr.append([temp, 1])
      if arr == []:
          arr.append([n, 1])
      return arr
  
  
  #####MakeDivisors######
  def make_divisors(n):
      divisors = []
      for i in range(1, int(n**0.5) + 1):
          if n % i == 0:
              divisors.append(i)
              if i != n // i:
                  divisors.append(n // i)
      return divisors
  
  
  #####MakePrimes######
  def make_primes(N):
      max = int(math.sqrt(N))
      seachList = [i for i in range(2, N + 1)]
      primeNum = []
      while seachList[0] <= max:
          primeNum.append(seachList[0])
          tmp = seachList[0]
          seachList = [i for i in seachList if i % tmp != 0]
      primeNum.extend(seachList)
      return primeNum
  
  
  #####GCD#####
  def gcd(a, b):
      while b:
          a, b = b, a % b
      return a
  
  
  #####LCM#####
  def lcm(a, b):
      return a * b // gcd(a, b)
  
  
  #####BitCount#####
  def count_bit(n):
      count = 0
      while n:
          n &= n - 1
          count += 1
      return count
  
  
  #####ChangeBase#####
  def base_10_to_n(X, n):
      if X // n:
          return base_10_to_n(X // n, n) + [X % n]
      return [X % n]
  
  
  def base_n_to_10(X, n):
      return sum(int(str(X)[-i - 1]) * n**i for i in range(len(str(X))))
  
  
  def base_10_to_n_without_0(X, n):
      X -= 1
      if X // n:
          return base_10_to_n_without_0(X // n, n) + [X % n]
      return [X % n]
  
  
  #####IntLog#####
  def int_log(n, a):
      count = 0
      while n >= a:
          n //= a
          count += 1
      return count
  
  
  #############
  # Main Code #
  #############
  
  
  def ACC1(l):
      N = len(l)
      ret = [0] * (N + 1)
      for i in range(N):
          ret[i + 1] = ret[i] + l[i]
      return ret
  
  
  N = I()
  T = IL()
  V = IL()
  ACCT = ACC1(T)
  
  TALL = sum(T)
  
  Lspeed = [min(i / 2, TALL - i / 2) for i in range(TALL * 2 + 1)]
  
  
  def f(i, j):
      t = i / 2
      start = ACCT[j]
      end = ACCT[j + 1]
      if start <= t <= end:
          return V[j]
      elif t < start:
          return V[j] + (start - t)
      else:
          return V[j] + (t - end)
  
  
  for i in range(TALL * 2 + 1):
      Lspeed[i] = min(Lspeed[i], min(f(i, j) for j in range(N)))
  
  ans = 0
  for i in range(TALL * 2):
      ans += Lspeed[i] + Lspeed[i + 1]
  
  print(ans / 4)
  
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"}]