Problem: Iahub has drawn a set of n points in the cartesian plane which he calls "special points". A quadrilateral is a simple polygon without self-intersections with four sides (also called edges) and four vertices (also called corners). Please note that a quadrilateral doesn't have to be convex. A special quadrilateral is one which has all four vertices in the set of special points. Given the set of special points, please calculate the maximal area of a special quadrilateral. 

Input

The first line contains integer n (4 ≤ n ≤ 300). Each of the next n lines contains two integers: xi, yi ( - 1000 ≤ xi, yi ≤ 1000) — the cartesian coordinates of ith special point. It is guaranteed that no three points are on the same line. It is guaranteed that no two points coincide. 

Output

Output a single real number — the maximal area of a special quadrilateral. The answer will be considered correct if its absolute or relative error does't exceed 10 - 9.

Examples

Input

5
0 0
0 4
4 0
4 4
2 3


Output

16.000000

Note

In the test example we can choose first 4 points to be the vertices of the quadrilateral. They form a square by side 4, so the area is 4·4 = 16.

Solution (in JAVA):

Solution:
import java.awt.color.*;
import java.util.*;


import java.awt.Point;
import java.math.*;
import java.io.*;
@SuppressWarnings("unused")
public class exponent {int[] b;String g="";int c=0;int m=1000000000+7;ArrayList<Integer> list=new ArrayList<Integer>();String s;int[] size;int[] id;
int[]ab;int[] data;int mod=100000;LinkedList<Integer> queue=new LinkedList<Integer>();int dis=0;int max=0;ArrayList<Integer>[] arr;
	public static void main(String[] args) {
              new  exponent().solve();
                                  }
	
            public void solve() {
            	int n=sc.nextInt();
            	double[][] a=new double[n][2];
            	for(int i=0;i<n;i++) {
            		double x=sc.nextDouble();double y=sc.nextDouble();
            		a[i][0]=x;a[i][1]=y;
            	}
            	double max=Double.MIN_VALUE; 	
            	double r=0,y=0;
            	for(int i=0;i<n;i++) {
            		for(int j=0;j<n;j++) {
            			if(i==j)
            				continue;
            			r=0;y=0;
            			for(int k=0;k<n;k++) {
            				if(j==k||k==i)
            					continue;
            				double f=a[j][1]-a[i][1];
            				double w=a[j][0]-a[i][0];
            				double m=f/w;
            				double x=a[k][1]-a[j][1]-m*a[k][0]+m*a[j][0];
            				
            				double g=Math.abs((a[j][1]-a[k][1])*a[i][0]+a[j][0]*(a[k][1]-a[i][1])+a[k][0]*(a[i][1]-a[j][1]));
            				g=g/2.0;
            				if(x<0) {
            					if(g>r)
            					r=g;}
            					
            				else if(x>0) {
            					if(g>y)
            						y=g;
            				}
            					
            				
            			}
            			if(y!=0&&r!=0)
            			{
            				if(max<y+r)
            					max=y+r;
            			}
            			            			
            			
            		}
            	}
            	System.out.println(max);
            	
       }
            public static int gcd(int a, int b)
            {
                if (a == 0)
                    return b;
                 
                return gcd(b%a, a);
            }
                
            long modularExponentiation(long x,long n,long M)
            {
                if(n==0)
                    return 1;
                else if(n%2 == 0)        //n is even
                    return modularExponentiation((x*x)%M,n/2,M);
                else                             //n is odd
                    return (long) ((x*modularExponentiation((x*x)%M,(n-1)/2,M))%M);

            }
            int modularExponentiation(long x,long n)
            {
                if(n==0)
                    return 1;
                else if(n%2 == 0)        //n is even
                    return modularExponentiation((x*x),n/2);
                else                             //n is odd
                    return (int) ((x*modularExponentiation((x*x),(n-1)/2)));

            }
            
            
            int modInverse(int a, int m)
            {
                int x=1, y=1;
                int g = gcdExtended(a, m, x, y);
               
                
                
                
                    // m is added to handle negative x
                    int res = (x%m + m) % m;
                    return res;
                
            }
             
           
            int gcdExtended(int a, int b, int x, int y)
            {
                // Base Case
                if (a == 0)
                {
                    x = 0; y = 1;
                    return b;
                }
             
                int x1=1, y1=1; // To store results of recursive call
                int gcd = gcdExtended(b%a, a, x1, y1);
             
                // Update x and y using results of recursive
                // call
                x = y1 - (b/a) * x1;
                y = x1;
             
                return gcd;}
      public class Node{
	     long x;long color;long y;
	       Node par;ArrayList<Point> pp=new ArrayList<Point>();
	        public Node(long a) {
	          	x=a;
		
	             }
                  }
              class sortbyweight implements Comparator<int[]>{

				@Override
				public int compare(int arg0[], int arg1[]) {
					// TODO Auto-generated method stub
					
					return (int)(arg0[0]-arg1[0]);
				}}
				
				 FastReader sc=new FastReader();
				 static class FastReader
				     {
				         BufferedReader br;
				         StringTokenizer st;
				  
				         public FastReader()
				         {
				             br = new BufferedReader(new
				                      InputStreamReader(System.in));
				         }
				  
				         String next()
				         {
				             while (st == null || !st.hasMoreElements())
				             {
				                 try
				                 {
				                     st = new StringTokenizer(br.readLine());
				                 }
				                 catch (IOException  e)
				                 {
				                     e.printStackTrace();
				                 }
				             }
				             return st.nextToken();
				         }
				  
				         int nextInt()
				         {
				             return Integer.parseInt(next());
				         }
				  
				         long nextLong()
				         {
				             return Long.parseLong(next());
				         }
				  
				         double nextDouble()
				         {
				             return Double.parseDouble(next());
				         }
				  
				         String nextLine()
				         {
				             String str = "";
				             try
				             {
				                 str = br.readLine();
				             }
				             catch (IOException e)
				             {
				                 e.printStackTrace();
				             }
				             return str;
				         }
				     }}