Problem: Ksusha is a vigorous mathematician. She is keen on absolutely incredible mathematical riddles. 

Today Ksusha came across a convex polygon of non-zero area. She is now wondering: if she chooses a pair of distinct points uniformly among all integer points (points with integer coordinates) inside or on the border of the polygon and then draws a square with two opposite vertices lying in the chosen points, what will the expectation of this square's area be?

A pair of distinct points is chosen uniformly among all pairs of distinct points, located inside or on the border of the polygon. Pairs of points p, q (p ≠ q) and q, p are considered the same.

Help Ksusha! Count the required expectation.

Input

The first line contains integer n (3 ≤ n ≤ 105) — the number of vertices of Ksusha's convex polygon. Next n lines contain the coordinates of the polygon vertices in clockwise or counterclockwise order. The i-th line contains integers xi, yi (|xi|, |yi| ≤ 106) — the coordinates of the vertex that goes i-th in that order.

Output

Print a single real number — the required expected area. 

The answer will be considered correct if its absolute and relative error doesn't exceed 10 - 6.

Examples

Input

3
0 0
5 5
5 0


Output

4.6666666667


Input

4
-1 3
4 5
6 2
3 -5


Output

8.1583333333


Input

3
17 136
859 937
16 641


Output

66811.3704155169

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
struct ppp {
  int x, y;
} p[370000];
long long num, res;
double ans;
int i, j, k, D[1000001 * 2 + 10], n, l, r, maxx;
void workx() {
  num = 0;
  res = 0;
  k = n + 1;
  maxx = p[1].x;
  for (i = n + 2; i <= n + n; ++i) {
    if (p[i].x < p[k].x) k = i;
    maxx = max(maxx, p[i].x);
  }
  l = r = k;
  for (i = p[k].x; i <= maxx; ++i) {
    while (l - 1 >= 1 && p[l - 1].x >= p[l].x && p[l - 1].x <= i) --l;
    while (r + 1 <= n * 3 && p[r + 1].x >= p[r].x && p[r + 1].x <= i) ++r;
    double u =
        double(p[l - 1].y - p[l].y) / (p[l - 1].x - p[l].x) * (i - p[l].x) +
        p[l].y;
    double d =
        double(p[r + 1].y - p[r].y) / (p[r + 1].x - p[r].x) * (i - p[r].x) +
        p[r].y;
    if (u < d) swap(u, d);
    D[i + 1000001] = int(floor(u) - ceil(d)) + 1;
    num += D[i + 1000001];
    res += (long long)i * D[i + 1000001];
  }
  for (j = p[k].x; j <= maxx; ++j) {
    ans += double(num - 1) * j * j * D[j + 1000001];
    ans -= double(res - j) * j * D[j + 1000001];
  }
}
void worky() {
  num = 0;
  res = 0;
  k = n + 1;
  maxx = p[1].y;
  for (i = n + 2; i <= n + n; ++i) {
    if (p[i].y < p[k].y) k = i;
    maxx = max(maxx, p[i].y);
  }
  l = r = k;
  for (i = p[k].y; i <= maxx; ++i) {
    while (l - 1 >= 1 && p[l - 1].y >= p[l].y && p[l - 1].y <= i) --l;
    while (r + 1 <= n * 3 && p[r + 1].y >= p[r].y && p[r + 1].y <= i) ++r;
    double u =
        double(p[l - 1].x - p[l].x) / (p[l - 1].y - p[l].y) * (i - p[l].y) +
        p[l].x;
    double d =
        double(p[r + 1].x - p[r].x) / (p[r + 1].y - p[r].y) * (i - p[r].y) +
        p[r].x;
    if (u < d) swap(u, d);
    D[i + 1000001] = int(floor(u) - ceil(d)) + 1;
    num += D[i + 1000001];
    res += (long long)i * D[i + 1000001];
  }
  for (j = p[k].y; j <= maxx; ++j) {
    ans += double(num - 1) * j * j * D[j + 1000001];
    ans -= double(res - j) * j * D[j + 1000001];
  }
}
int main() {
  scanf("%d", &n);
  for (i = 1; i <= n; ++i) {
    scanf("%d%d", &p[i].x, &p[i].y);
    p[i + n] = p[i + n + n] = p[i];
  }
  p[0] = p[n];
  p[n + n + n + 1] = p[1];
  workx();
  worky();
  printf("%.10lf\n", ans / num / (num - 1));
}