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 Point {
  int x, y;
  void init() {
    scanf("%d%d", &x, &y);
    x += 1000000;
    y += 1000000;
  }
  void swap() {
    x ^= y;
    y ^= x;
    x ^= y;
  }
};
const int MAXN = 100000;
int n;
Point points[MAXN];
int fix(int x) { return x < 0 ? x + n : x >= n ? x - n : x; }
int getLower(int x, const Point &u, const Point &v) {
  if (u.x == v.x) return min(u.y, v.y);
  return (v.y * (long long)(v.x - u.x) - (v.x - x) * (long long)(v.y - u.y) +
          v.x - u.x - 1) /
         (v.x - u.x);
}
int getUpper(int x, const Point &u, const Point &v) {
  if (u.x == v.x) return max(u.y, v.y);
  return (v.y * (long long)(v.x - u.x) - (v.x - x) * (long long)(v.y - u.y)) /
         (v.x - u.x);
}
long double squareSum(long double l, long double u) {
  long double res = (u - l + 1) / 6;
  res += (u - l + 1) * (u + l - 1) / 2;
  res += (u - l + 1) * (u * u + u * (l - 1) + (l - 1) * (l - 1)) / 3;
  return res;
}
long double calc() {
  int p1 = 0, d1, p2, d2, minx = points[0].x, maxx = points[0].x;
  for (int i = (1); i < (n); i++) {
    if (points[p1].x > points[i].x) p1 = i;
    minx = min(minx, points[i].x);
    maxx = max(maxx, points[i].x);
  }
  p2 = p1;
  d1 = 1;
  d2 = -1;
  if (points[fix(p1 + d1)].y > points[fix(p2 + d2)].y) swap(d1, d2);
  long double sum = 0, sum2 = 0, m = 0;
  for (int x = (minx); x < (maxx + 1); x++) {
    int nxtp1 = fix(p1 + d1), nxtp2 = fix(p2 + d2);
    int lower = getLower(x, points[p1], points[nxtp1]);
    int upper = getUpper(x, points[p2], points[nxtp2]);
    if (points[nxtp1].x == x) p1 = nxtp1;
    if (points[nxtp2].x == x) p2 = nxtp2;
    m += upper - lower + 1;
    sum += (lower + upper) * (upper - lower + 1.0) / 2;
    sum2 += squareSum(lower, upper);
  }
  return sum2 / (m - 1) - sum / m / (m - 1) * sum;
}
int main() {
  scanf("%d", &n);
  for (int i = (0); i < (n); i++) points[i].init();
  long double res = calc();
  for (int i = (0); i < (n); i++) points[i].swap();
  res += calc();
  printf("%.16lf\n", (double)res);
  return 0;
}