For this Question: You are given N points on a plane, the i<sup>th</sup> point being (x<sub>i</sub>, y<sub>i</sub>). Find the largest area of any parallelogram you can construct from those N points. If no parallelogram can be constructed, print 0. 

It can be easily shown that the answer must be an integer.The first line of the input contains a single integer N — the number of points. 
Each of the next N lines describes a point on the cartesian plane: the i<sup>th</sup> line contains two integers x<sub>i</sub> and y<sub>i</sub>  — the coordinates of the i<sup>th</sup> point. 

The given points are not necessarily distinct. Any three points may or may not be collinear.

<b>Constraints:</b>
1 ≤ N ≤ 10<sup>3</sup>
0 ≤ x<sub>i</sub>, y<sub>i</sub> ≤ 10<sup>9</sup>Print a single integer — the maximum area of a parallelogram that can be constructed from the N points, or print 0 if no such parallelogram can be constructed.Sample Input:
5
1 0
4 0
4 4
7 4
6 1

Sample Output:
12

Explanation:
Take the points indexed 1, 2, 3 and 4. This gives a parallelogram of area 12., I have written this Solution Code: //Author: hyperion_1724
//Time and Date: 19:04:32  18 September 2020

//Optional FAST
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,fma,abm,mmx,avx,avx2,tune=native")

//Required Libraries

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>

//Required namespaces

using namespace std;
using namespace __gnu_pbds;

//Required defines

#define endl '\n'

#define READ(X) cin>>X;
#define READV(X) long long X; cin>>X;
#define READAR(A,N) long long A[N]; for(long long i=0;i<N;i++) {cin>>A[i];}
#define rz(A,N) A.resize(N);
#define sz(X) (long long)(X.size())
#define pb push_back
#define pf push_front
#define fi first
#define se second
#define FORI(a,b,c) for(long long a=b;a<c;a++)
#define FORD(a,b,c) for(long long a=b;a>c;a--)

//Required typedefs

template <typename T> using ordered_set = tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
template <typename T> using ordered_set1 = tree<T,null_type,greater<T>,rb_tree_tag,tree_order_statistics_node_update>;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<long long,long long> pll;

//Required Constants

const long long inf=(long long)1e18;
const long long MOD=(long long)(1e9+7);
const long long INIT=(long long)(1e6+1);
const long double PI=3.14159265358979;

// Required random number generators

// mt19937 gen_rand_int(chrono::steady_clock::now().time_since_epoch().count());
// mt19937_64 gen_rand_ll(chrono::steady_clock::now().time_since_epoch().count());

//Required Functions

ll power(ll x,ll y) 
{ 
    if (y == 0) 
        return 1; 
    ll p = power(x, y/2) % MOD; 
    p = (p * p) % MOD; 
  
    return (y%2 == 0)? p : (x * p) % MOD; 
}
ll modInverse(ll a) 
{ 
   return power(a,MOD-2); 
   
}

//Work

int main()
{
    #ifndef ONLINE_JUDGE
    if (fopen("INPUT.txt", "r"))
    {
        freopen ("INPUT.txt" , "r" , stdin);
        //freopen ("OUTPUT.txt" , "w" , stdout);
    }
    #endif
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    clock_t clk;
    clk = clock();
//-----------------------------------------------------------------------------------------------------------//

    READV(N);
    map<pair<ll,pll>,pll> Z;
    map<ll,pll> vert_handler;
    vector<pair<ll,ll>> points;
    FORI(i,0,N)
    {
        READV(x);
        READV(y);
        points.pb({x,y});
    }
    FORI(i,0,N)
    {
        FORI(j,0,N)
        {
            if(i!=j && points[i].fi!=points[j].fi)
            {
                ll a=points[i].se-points[j].se;
                ll b=points[i].fi-points[j].fi;
                ll dist=a*a+b*b;
                if(b<0)
                {
                    a=-a;
                    b=-b;
                }
                ll c=b*points[i].se-a*points[i].fi;
                if(a==0)
                {
                    b=1;
                }
                else
                {
                    ll g=__gcd(abs(a),abs(b));
                    a=a/g;
                    b=b/g;
                }
                if(Z.count({dist,{a,b}})==0)
                {
                    Z[{dist,{a,b}}]={c,c};
                }
                else
                {
                    Z[{dist,{a,b}}].fi=max(Z[{dist,{a,b}}].fi,c);
                    Z[{dist,{a,b}}].se=min(Z[{dist,{a,b}}].se,c);
                }
            }
            else if(i!=j && points[i].fi==points[j].fi)
            {
                ll a=points[i].se-points[j].se;
                ll b=points[i].fi-points[j].fi;
                ll c=points[i].fi;
                ll dist=abs(a);
                if(vert_handler.count(dist)==0)
                {
                    vert_handler[dist]={c,c};
                }
                else
                {
                    vert_handler[dist].fi=max(vert_handler[dist].fi,c);
                    vert_handler[dist].se=min(vert_handler[dist].se,c);
                }
            }
        }
    }
    ll ans=0;
    for(auto x:vert_handler)
    {
        ll ans1=x.fi*(x.se.fi-x.se.se);
        ans=max(ans,ans1);
    }
    for(auto x:Z)
    {
        ans=max(ans,x.se.fi-x.se.se);
    }
    cout<<ans<<endl;

//-----------------------------------------------------------------------------------------------------------//


    clk = clock() - clk;
    cerr << fixed << setprecision(6) << "Time: " << ((double)clk)/CLOCKS_PER_SEC << endl;

    return 0;
}, In this Programming Language: C++, Now tell me if this Code is compilable or not?