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 {
  long double x, y;
  inline Point(long double xx = 0, long double yy = 0) : x(xx), y(yy) {}
  inline void read() {
    double x0 = 0, y0 = 0;
    scanf("%lf%lf", &x0, &y0);
    x = x0 + 1000000;
    y = y0 + 1000000;
  }
  inline long double operator*(const Point &A) const {
    return x * A.y - y * A.x;
  }
  inline Point operator+(const Point &A) const {
    return Point(x + A.x, y + A.y);
  }
  inline Point operator-(const Point &A) const {
    return Point(x - A.x, y - A.y);
  }
  inline int operator<(const Point &A) const {
    if (x != A.x) return x < A.x;
    return y < A.y;
  }
} P[100005];
int dA, dB, A, B, c, vis[100005], n;
long double sy, sy2, sx, sx2, num, ans;
inline int next(int x) {
  x++;
  if (x > n) x = 1;
  return x;
}
inline int prev(int x) {
  --x;
  if (x < 1) x = n;
  return x;
}
inline long double ask(int A, int B, int x) {
  if (P[B].x == P[A].x) return P[B].y;
  long double lamda = (x - P[A].x) / (P[B].x - P[A].x);
  return lamda * (P[B].y - P[A].y) + P[A].y;
}
inline long double ask(long double x) {
  if (x <= 0) return 0;
  return x * (x + 1) * (2 * x + 1) / 6.0;
}
int Max;
int main() {
  scanf("%d", &n);
  for (int i = (1); i <= (n); i++) P[i].read();
  c = 1;
  for (int i = (2); i <= (n); i++)
    if (P[i] < P[c]) c = i;
  for (int i = (1); i <= (n); i++)
    if (P[i].x > Max) Max = P[i].x;
  A = next(c);
  B = prev(c);
  dA = dB = c;
  vis[dA] = 1;
  for (long double Nowx = P[c].x; Nowx <= Max; Nowx++) {
    long double uy = ask(dA, A, Nowx), dy = ask(dB, B, Nowx);
    if (uy < dy) swap(uy, dy);
    long double Uy = floor(uy), Dy = ceil(dy);
    num += Uy - Dy + 1;
    sx += Nowx * (Uy - Dy + 1);
    sx2 += Nowx * Nowx * (Uy - Dy + 1);
    sy += (Dy + Uy) * (Uy - Dy + 1) / 2.0;
    sy2 += ask(Uy) - ask(Dy - 1);
    if (Nowx == P[A].x) {
      dA = A;
      vis[dA] = 1;
      int cho1 = prev(dA), cho2 = next(dA);
      if (vis[cho1])
        A = cho2;
      else
        A = cho1;
    }
    if (Nowx == P[B].x) {
      dB = B;
      vis[dB] = 1;
      int cho1 = prev(dB), cho2 = next(dB);
      if (vis[cho1])
        B = cho2;
      else
        B = cho1;
    }
  }
  ans += (num)*sx2 - sx * sx;
  ans += (num)*sy2 - sy * sy;
  ans /= num;
  ans /= (num - 1);
  printf("%.12lf\n", double(ans));
  return 0;
}