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.io.BufferedInputStream;
import java.io.IOException;
import java.util.InputMismatchException;
import java.util.Scanner;

/**
 * Created by jizhe on 2016/1/9.
 */
public class MaximalAreaQuadrilateral {
    public static class FasterScanner {
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public int read() {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = System.in.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndOfLine(c));
            return res.toString();
        }

        public String nextString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public int[] nextIntArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextInt();
            }
            return arr;
        }

        public long[] nextLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }
            return arr;
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }
    }

    private static long GCD(long a, long b)
    {
        long tmp = b;
        while( b != 0 )
        {
            tmp = b;
            b = a%b;
            a = tmp;
        }

        return tmp;
    }

    public static void main(String[] args) {
        //Scanner in = new Scanner(new BufferedInputStream(System.in));
        FasterScanner in = new FasterScanner();

        //System.out.printf("%d\n", GCD(in.nextInt(), in.nextInt()));
        int N = in.nextInt();
        long[] x = new long[N];
        long[] y = new long[N];

        for( int i = 0; i < N; i++ )
        {
            x[i] = in.nextInt();
            y[i] = in.nextInt();
        }

        //ax+by+c=0
        double maxArea = 1;
        for( int i = 0; i < N; i++ )
        {
            long a, b, c;
            for( int j = i+1; j < N; j++ )
            {
                //System.out.printf("(%d, %d) and (%d, %d):\n", x[i], y[i], x[j], y[j]);
                long t1 = y[i]-y[j];
                long t2 = x[i]*y[j]-x[j]*y[i];
                //System.out.printf("t1: %d, t2: %d\n", t1, t2);
                if( t1 == 0 )
                {
                    //System.out.printf("t1 equal zero\n");
                    a = 0;
                    b = 1;
                    if( y[i] == 0 )
                    {
                        c = 0;
                    }
                    else
                    {
                        c = -y[i];
                    }
                }
                else if( t2 == 0 )
                {
                    //System.out.printf("t2 equal zero\n");;
                    c = 0;
                    if( x[i] == 0 && x[j] == 0 )
                    {
                        a = 1;
                        b = 0;
                    }
                    else if( x[i] == 0 )
                    {
                        //y[i] must be zero
                        long t3 = -y[j], t4 = x[j];
                        long gcd2 = GCD(t3, t4);
                        long p2 = t3/gcd2, q2 = t4/gcd2;
                        a = p2;
                        b = q2;
                    }
                    else
                    {
                        //y[j] must be zero
                        long t3 = -y[i], t4 = x[i];
                        long gcd2 = GCD(t3, t4);
                        long p2 = t3/gcd2, q2 = t4/gcd2;
                        a = p2;
                        b = q2;
                    }
                }
                else
                {
                    long gcd = GCD(t1, t2);
                    long p = t1/gcd, q = t2/gcd;
                    long t3, t4;
                    if( y[i] == 0 )
                    {
                        t3 = -p*x[j]-q;
                        t4 = y[j];
                    }
                    else
                    {
                        t3 = -p*x[i]-q;
                        t4 = y[i];
                    }

                    long gcd2 = GCD(t3, t4);
                    long p2 = t3/gcd2, q2 = t4/gcd2;
                    a = p*q2;
                    b = p2;
                    c = q*q2;

                    //System.out.printf("gcd: %d, p: %d, q: %d, t3: %d, t4: %d, p2: %d, q2: %d\n", gcd, p, q, t3, t4, p2, q2);
                }

                //System.out.printf("a: %d, b: %d, c: %d\n", a, b, c);

                if( a*x[i]+b*y[i]+c != 0 || a*x[j]+b*y[j]+c != 0 )
                {
                    System.out.printf("Compute error!!!!!!\n");
                }

                double commonLen = Math.pow((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]), 0.5);
                double absABPow = Math.pow(a*a+b*b, 0.5);

                double maxPositive = 0, maxNegative = 0;
                for( int k = 0; k < N; k++ )
                {
                    if( k == i || k == j )
                    {
                        continue;
                    }

                    double distanceK = Math.abs(a*x[k]+b*y[k]+c)/absABPow;
                    if( a*x[k]+b*y[k]+c > 0 )
                    {
                        if( distanceK > maxPositive )
                        {
                            maxPositive = distanceK;
                        }
                    }
                    else
                    {
                        if( distanceK > maxNegative )
                        {
                            maxNegative = distanceK;
                        }
                    }
                }

                if( maxPositive == 0 || maxNegative == 0 )
                {
                    continue;
                }

                maxArea = Math.max(maxArea, (maxPositive+maxNegative)*commonLen/2);
            }
        }

        System.out.printf("%f\n", maxArea);
    }
}