Pavel made a photo of his favourite stars in the sky. His camera takes a photo of all points of the sky that belong to some rectangle with sides parallel to the coordinate axes.

Strictly speaking, it makes a photo of all points with coordinates (x, y), such that x_1 ≤ x ≤ x_2 and y_1 ≤ y ≤ y_2, where (x_1, y_1) and (x_2, y_2) are coordinates of the left bottom and the right top corners of the rectangle being photographed. The area of this rectangle can be zero.

After taking the photo, Pavel wrote down coordinates of n of his favourite stars which appeared in the photo. These points are not necessarily distinct, there can be multiple stars in the same point of the sky.

Pavel has lost his camera recently and wants to buy a similar one. Specifically, he wants to know the dimensions of the photo he took earlier. Unfortunately, the photo is also lost. His notes are also of not much help; numbers are written in random order all over his notepad, so it's impossible to tell which numbers specify coordinates of which points.

Pavel asked you to help him to determine what are the possible dimensions of the photo according to his notes. As there are multiple possible answers, find the dimensions with the minimal possible area of the rectangle.

Input

The first line of the input contains an only integer n (1 ≤ n ≤ 100 000), the number of points in Pavel's records.

The second line contains 2 ⋅ n integers a_1, a_2, ..., a_{2 ⋅ n} (1 ≤ a_i ≤ 10^9), coordinates, written by Pavel in some order.

Output

Print the only integer, the minimal area of the rectangle which could have contained all points from Pavel's records.

Examples

Input

4
4 1 3 2 3 2 1 3


Output

1

Input

3
5 8 5 5 7 5


Output

0

Note

In the first sample stars in Pavel's records can be (1, 3), (1, 3), (2, 3), (2, 4). In this case, the minimal area of the rectangle, which contains all these points is 1 (rectangle with corners at (1, 3) and (2, 4)).
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
  if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
  if (x < y) x = y;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const pair<T, U> &_p) {
  _out << _p.first << ' ' << _p.second;
  return _out;
}
template <typename T, typename U>
inline istream &operator>>(istream &_in, pair<T, U> &_p) {
  _in >> _p.first >> _p.second;
  return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const vector<T> &_v) {
  if (_v.empty()) {
    return _out;
  }
  _out << _v.front();
  for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) {
    _out << ' ' << *_it;
  }
  return _out;
}
template <typename T>
inline istream &operator>>(istream &_in, vector<T> &_v) {
  for (auto &_i : _v) {
    _in >> _i;
  }
  return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const set<T> &_s) {
  if (_s.empty()) {
    return _out;
  }
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
    _out << ' ' << *_it;
  }
  return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const multiset<T> &_s) {
  if (_s.empty()) {
    return _out;
  }
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
    _out << ' ' << *_it;
  }
  return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_set<T> &_s) {
  if (_s.empty()) {
    return _out;
  }
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
    _out << ' ' << *_it;
  }
  return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_multiset<T> &_s) {
  if (_s.empty()) {
    return _out;
  }
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
    _out << ' ' << *_it;
  }
  return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const map<T, U> &_m) {
  if (_m.empty()) {
    return _out;
  }
  _out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
  for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
    _out << ", (" << _it->first << ": " << _it->second << ')';
  }
  return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const unordered_map<T, U> &_m) {
  if (_m.empty()) {
    return _out;
  }
  _out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
  for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
    _out << ", (" << _it->first << ": " << _it->second << ')';
  }
  return _out;
}
const long long N = 1e6;
long long num[N];
long long tree[4 * N];
long long tree2[4 * N];
void build(long long idx, long long s, long long e) {
  if (s > e) return;
  if (s == e) {
    tree[idx] = num[s];
    return;
  }
  long long m = (s + e) / 2;
  build(2 * idx, s, m);
  build(2 * idx + 1, m + 1, e);
  tree[idx] = min(tree[2 * idx], tree[2 * idx + 1]);
  return;
}
long long query(long long idx, long long s, long long e, long long l,
                long long r) {
  if (l > e || r < s) return 1e9;
  if (s >= l && e <= r) {
    return tree[idx];
  }
  long long m = (s + e) / 2;
  long long left = query(2 * idx, s, m, l, r);
  long long right = query(2 * idx + 1, m + 1, e, l, r);
  return min(left, right);
}
void build2(long long idx, long long s, long long e) {
  if (s > e) return;
  if (s == e) {
    tree2[idx] = num[s];
    return;
  }
  long long m = (s + e) / 2;
  build2(2 * idx, s, m);
  build2(2 * idx + 1, m + 1, e);
  tree2[idx] = max(tree2[2 * idx], tree2[2 * idx + 1]);
  return;
}
long long query2(long long idx, long long s, long long e, long long l,
                 long long r) {
  if (l > e || r < s) return -1e9;
  if (s >= l && e <= r) {
    return tree2[idx];
  }
  long long m = (s + e) / 2;
  long long left = query2(2 * idx, s, m, l, r);
  long long right = query2(2 * idx + 1, m + 1, e, l, r);
  return max(left, right);
}
int32_t main() {
  long long n;
  cin >> n;
  for (long long i = 0; i < 2 * n; i++) {
    cin >> num[i];
  }
  sort(num, num + 2 * n);
  build(1, 0, 2 * n - 1);
  build2(1, 0, 2 * n - 1);
  long long res = LLONG_MAX;
  for (long long i = 0; i < 2 * n - n + 1; i++) {
    long long max_sec = query2(1, 0, 2 * n - 1, i, i + n - 1);
    long long min_sec = query(1, 0, 2 * n - 1, i, i + n - 1);
    long long max_other = query2(1, 0, 2 * n - 1, 0, i - 1);
    max_other = max(query2(1, 0, 2 * n - 1, i + n, 2 * n - 1), max_other);
    long long min_other = query(1, 0, 2 * n - 1, 0, i - 1);
    min_other = min(query(1, 0, 2 * n - 1, i + n, 2 * n - 1), min_other);
    long long cur = abs(max_sec - min_sec) * abs(max_other - min_other);
    res = min(res, cur);
  }
  cout << res << endl;
  return 0;
}
