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;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
struct poi {
  ll x, y;
  poi operator-(poi p) { return {x - p.x, y - p.y}; }
  bool operator<(poi p) const { return tie(x, y) < tie(p.x, p.y); }
  ll cross(poi p) { return x * p.y - y * p.x; }
};
ll xmul(poi a, poi b, poi c) { return (b - a).cross(c - a); }
using vp = vector<poi>;
vp convex(vp v) {
  sort(v.begin(), v.end());
  vp r;
  for (int i = 0; i < v.size(); i++) {
    while (r.size() > 1 && xmul(*++r.rbegin(), v[i], *r.rbegin()) >= 0)
      r.pop_back();
    r.push_back(v[i]);
  }
  int d = r.size();
  for (int i = (int)v.size() - 2; i >= 0; i--) {
    while (r.size() > d && xmul(*++r.rbegin(), v[i], *r.rbegin()) >= 0)
      r.pop_back();
    if (i != 0) r.push_back(v[i]);
  }
  return r;
}
ll f(ll a, ll b) {
  if (a >= 0) return a / b;
  return a / b - bool(a % b);
}
ll g(ll a, ll b) { return f(a + b - 1, b); }
ld solve(vp v) {
  v = convex(v);
  v.push_back(v[0]);
  vp up, down;
  for (int i = 0; i < v.size(); i++)
    if (!i || v[i].x > v[i - 1].x)
      down.push_back(v[i]);
    else
      break;
  while (v.back().x == (++v.rbegin())->x) v.pop_back();
  reverse(v.begin(), v.end());
  for (int i = 0; i < v.size(); i++)
    if (!i || v[i].x > v[i - 1].x)
      up.push_back(v[i]);
    else
      break;
  int j = 0, k = 0;
  vector<pii> xs;
  ld c = 0, s = 0, s2 = 0;
  for (int i = up[0].x; i <= up.back().x; i++) {
    while (up[j + 1].x < i) j++;
    while (down[k + 1].x < i) k++;
    ll u = f((up[j + 1].y - up[j].y) * (i - up[j].x), up[j + 1].x - up[j].x) +
           up[j].y;
    ll d = g((down[k + 1].y - down[k].y) * (i - down[k].x),
             down[k + 1].x - down[k].x) +
           down[k].y;
    xs.push_back({i, u - d + 1});
    c += u - d + 1;
    s += i * (u - d + 1);
    s2 += ld(i) * i * (u - d + 1);
  }
  ld ret = 0;
  for (pii p : xs) {
    ret += ld(p.first) * p.first * c * p.second;
    ret += -2.0L * p.first * s * p.second;
    ret += s2 * p.second;
  }
  return ret / c / (c - 1);
}
int main() {
  int n;
  cin >> n;
  vp v;
  while (n--) {
    poi p;
    cin >> p.x >> p.y;
    v.push_back(p);
  }
  ld ans = 0;
  for (int t = 0; t < 2; t++) {
    ans += solve(v);
    for (auto &p : v) swap(p.x, p.y);
  }
  cout << fixed << setprecision(9) << ans / 2 << '\n';
}