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;
long long fpm(long long b, long long e, long long m) {
  long long t = 1;
  for (; e; e >>= 1, b = b * b % m) e & 1 ? t = t * b % m : 0;
  return t;
}
template <class T>
inline bool chkmin(T &a, T b) {
  return a > b ? a = b, true : false;
}
template <class T>
inline bool chkmax(T &a, T b) {
  return a < b ? a = b, true : false;
}
template <class T>
inline T sqr(T x) {
  return x * x;
}
template <typename T>
T gcd(T x, T y) {
  for (T t; x; t = x, x = y % x, y = t)
    ;
  return y;
}
template <class edge>
struct Graph {
  vector<vector<edge> > adj;
  Graph(int n) {
    adj.clear();
    adj.resize(n + 5);
  }
  Graph() { adj.clear(); }
  void resize(int n) { adj.resize(n + 5); }
  void add(int s, edge e) { adj[s].push_back(e); }
  void del(int s, edge e) { adj[s].erase(find(iter(adj[s]), e)); }
  vector<edge> &operator[](int t) { return adj[t]; }
};
const int U = 1100000, maxn = U;
const long double eps = 1e-10;
int n;
long double tot;
set<long double> S[U * 2 + 10];
int x[maxn], y[maxn];
int w[maxn];
long double work() {
  long double ret = 0;
  for (int _end_ = (U + U), i = (0); i <= _end_; ++i) S[i].clear();
  for (int _end_ = (n), i = (1); i <= _end_; ++i) {
    int l = i, r = i % n + 1;
    if (x[l] > x[r]) swap(l, r);
    if (x[l] == x[r]) {
      S[x[l] + U].insert(y[l]);
      S[x[r] + U].insert(y[r]);
      continue;
    }
    for (int _end_ = (x[r]), a = (x[l]); a <= _end_; ++a) {
      S[a + U].insert(
          (long double)(1ll * y[l] * (x[r] - a) + 1ll * y[r] * (a - x[l])) /
          (x[r] - x[l]));
    }
  }
  long double S0 = 0, S1 = 0, S2 = 0;
  for (int _end_ = (U), i = (-U); i <= _end_; ++i) {
    if (!(int)((S[i + U]).size())) continue;
    long double l = *S[i + U].begin(), r = *--S[i + U].end();
    int lb = ceil(l - eps);
    int rb = floor(r + eps);
    long double v = rb - lb + 1;
    ret += v * (S2 - 2 * S1 * i + S0 * i * i);
    S2 += 1.0 * v * i * i;
    S1 += 1.0 * v * i;
    S0 += 1.0 * v;
  }
  cerr << "ret: " << ret << " " << S0 << endl;
  if (tot) assert(tot == S0);
  tot = S0;
  for (int _end_ = (n), i = (1); i <= _end_; ++i) swap(x[i], y[i]);
  return ret;
}
int main(int argc, char **argv) {
  ios_base::sync_with_stdio(false);
  cin >> n;
  for (int _end_ = (n), i = (1); i <= _end_; ++i) {
    cin >> x[i] >> y[i];
  }
  cout << setprecision(15) << (work() + work()) / tot / (tot - 1) << endl;
  return 0;
}