/**
 * Deon Nicholas' solution to InTents.
 *
 * The secret (besides fighting with volume formulas)
 * is that the problem can be solved greedily.
 * 
 * --------------------------------------
 * THE VOLUME FORMULA:
 *
 * First, assue we have already assigned all posts to locations.
 *
 * What is the volume of a single "triangle", assuming you place
 * posts with heights h1 and h2 respectively, and your origin post has height z?
 *
 * ==> (h1 + h2 + z) * (AREA / 3)
 *
 * Where AREA is the flat / birds-eye-view area of the triangle. (I derived
 * this by breaking the thing into a pair of smaller tetrahedra.)
 *
 * Summing over all the triangles, each h_i will be included in two
 * triangles (those that are incident to it). So a given h_i will contribute:
 *
 * (h_i*AREA_i1/3) + (h_i*AREA_i2/3)
 *
 * to the overall sum, where AREA_i1 and AREA_i2 are the areas of the triangles
 * that include that post.
 *
 * ==> h_i * (AREA_i1 + AREA_i2)/3
 * --------------------------------------
 *
 * --------------------------------------
 * MAXIMIZING TOTAL VOLUME:
 *
 * Incidentally, the volume contributed by a single post of height h_i
 * is completely independent of the other posts.
 *
 * So, to maximize the volume, we simply need to place the posts in such a way
 * as to maximize: sum{h_i * (AREA_i1 + AREA_i2)/3}
 *
 * Using a Greedy Argument you can prove that you should *always* place the maximum
 * h_i with the maximum (AREA_i1 + AREA_i2)/3, and the second with the second,
 * etc, if you want to maximize the total sum (exercise?).
 *
 * So that's actually it. We sort the (AREA_i1 + AREA_i2) / 3, for all neighbouring
 * triangles, and sort the h_i, and add up the matching products.
 *
 * Oh, and since we don't know the origin post
 * right away, we just try all those.
 *
 * Overall run-time is O(N^2 log N) or O(N^2) if you're not lazy.
 * --------------------------------------
 */ 

#include <iostream>
#include <cmath>
#include <cstring>
#include <cassert>
#include <cstdio>
#include <algorithm>
#include <iomanip>

using namespace std;

#define FOR(i,n) for(int i=0;i<(n);++i)
#define MAXN 50

typedef long double ld;
typedef pair<int,int> pii;

pii pts[MAXN];      // the points on the periphery
int H[MAXN];        // height of post i

ld area[MAXN];      // area of each triangle (birds-eye-view)
ld sum_adj[MAXN];   // sum of adjacent areas: (area[i] + area[i+1]) / 3
ld tmp[MAXN];

// Solve greedily
// Always match the tallest post with the point where it will contribute most
// Contribution to volume is always sum_adj[i] * H[i]
ld solve(int N, int P, int Z) {
  ld base = 0;
  FOR(i,P) base += Z*area[i]/3.0;
  FOR(i,N) tmp[i] = H[i];
  sort(tmp,tmp+N);

  assert(N == P);
  FOR(i,N) base += tmp[i]*sum_adj[i];
  return base;
}

ld theta(int x, int y) { return atan2(y,x); }
ld theta(const pii& p) { return theta(p.first, p.second); }
bool sort_by_angle(const pii& a, const pii& b) {
  return (a==b ? false : (theta(a) < theta(b)));
}

int main() {
  int N;
  scanf("%d", &N);
  int P = N-1;  // P:= number of holes on periphal

  // input
  FOR(i,P) scanf("%d%d",&pts[i].first,&pts[i].second);
  FOR(i,N) scanf("%d",&H[i]);

  // sort points by angle around origin
  sort(pts, pts+P, sort_by_angle);

  // Compute the base areas of each triangle (birds-eye view)
  FOR(i,P) {
    int x1 = pts[i].first, h1 = pts[i].second;
    int x2 = pts[(i+1)%P].first, h2 = pts[(i+1)%P].second;

    // area of a triangle = 0.5 * [cross-product of it's two non-origin points]
    int cross = x1*h2 - h1*x2;  
    area[i] = abs(cross / 2.0l);
  }

  // For each pair of adjacent triangles, sum their areas (divide by 3 to fit the formulas)
  FOR(i,P) sum_adj[i] = (area[i] + area[(i+1)%P]) / 3.0;
  sort(sum_adj,sum_adj+P);

  // Try all possible "origins", solve, take the best
  ld ans = 0;
  FOR(i,N) {
    swap(H[i], H[N-1]);
    ans = max(ans, solve(N-1, P, H[N-1]));
    swap(H[i], H[N-1]);
  }

  cout << fixed << setprecision(2) << ans << endl;
}