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;
void Get(int &T) {
  char C;
  bool F = 0;
  for (; C = getchar(), C < '0' || C > '9';)
    if (C == '-') F = 1;
  for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
    ;
  F && (T = -T);
}
pair<int, int> A[1000005];
int N;
void Init() {
  Get(N);
  for (int i = 1; i <= N; i++) {
    Get(A[i].first);
    Get(A[i].second);
    A[i].first += 1000005;
    A[i].second += 1000005;
  }
}
double Floor(int X, int Y, int P) {
  double Y1 = A[X].second + (double)(P - A[X].first) /
                                (double)(A[Y].first - A[X].first) *
                                (double)(A[Y].second - A[X].second);
  return floor(Y1 + 0);
}
double Ceil(int X, int Y, int P) {
  double Y1 = A[X].second + (double)(P - A[X].first) /
                                (double)(A[Y].first - A[X].first) *
                                (double)(A[Y].second - A[X].second);
  return ceil(Y1 - 0);
}
long long F[10000005];
double Ans;
void Calc() {
  rotate(A + 1, min_element(A + 1, A + N + 1), A + N + 1);
  A[N + 1] = A[1];
  int Pos = max_element(A + 1, A + N + 1) - A;
  int P = A[1].first, Q = A[Pos].first;
  for (int i = P, k = 1; i <= Q; i++) {
    for (; A[k + 1].first < i;) k++;
    int Pos = Ceil(k, k + 1, i);
    F[i] = -Pos + 1;
  }
  long long Cnt = 0;
  long long SumX = 0;
  for (int i = Q, k = Pos; i >= P; i--) {
    for (; A[k + 1].first > i;) k++;
    int Pos = Floor(k, k + 1, i);
    F[i] += Pos;
    Cnt += F[i];
    SumX += (i - 1000005) * F[i];
  }
  double Ans0 = 0;
  for (int i = Q; i >= P; i--)
    Ans0 += (double)F[i] * (i - 1000005) * (i - 1000005) * Cnt;
  Ans0 -= (double)SumX * SumX;
  Ans0 /= ((double)(Cnt - 1) * Cnt);
  Ans += Ans0;
}
void Work() {
  double S = 0;
  A[N + 1] = A[1];
  for (int k = 1; k <= N + 1; k++)
    S += (double)A[k].first * (double)A[k + 1].second -
         (double)A[k].second * (double)A[k + 1].first;
  if (S < 0) reverse(A + 1, A + N + 1);
  Calc();
  for (int k = 1; k <= N; k++) std::swap(A[k].first, A[k].second);
  reverse(A + 1, A + N + 1);
  Calc();
}
void Output() { printf("%.15lf\n", (double)Ans); }
int main() {
  Init();
  Work();
  Output();
  return 0;
}