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.IOException;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Comparator;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author karan173
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskB {
    public void solve(int testNumber, FastReader in, PrintWriter out)
    {
        int n = in.nextInt ();
        MyPoint2D p[] = new MyPoint2D[n];
        for (int i = 0; i < n; i++)
        {
            p[i] = new MyPoint2D (in.nextInt (), in.nextInt (), i);
        }
        double maxArea = 0.0;
        double eps = 1e-10;
        for (int i = 0; i < n; i++)
        {
            for (int j = i + 1; j < n; j++)
            {
                //vector 1 is pi to pj
                //vector 2 is pi to pk
                double maxPosArea = 0.0, maxNegArea = 0.0;
                for (int k = 0; k < n; k++)
                {
                    if (k == i || k == j)
                    {
                        continue;
                    }
                    double area = -0.5 * MyPoint2D.cross (p[j], p[i], p[k]);
                    if (area < 0.0)
                    {
                        maxNegArea = Math.max (maxNegArea, -area);
                    }
                    else
                    {
                        maxPosArea = Math.max (maxPosArea, area);
                    }
                }
                if (maxPosArea > 0.0 && maxNegArea > 0.0)
                {
                    maxArea = Math.max (maxArea, maxNegArea + maxPosArea);
                }
            }
        }
        out.println (maxArea);
    }
}

class FastReader
{

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public FastReader(InputStream stream)
    {
        this.stream = stream;
    }

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

    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 boolean isSpaceChar(int c)
    {
        if (filter != null)
        {
            return filter.isSpaceChar (c);
        }
        return isWhitespace (c);
    }

    public static boolean isWhitespace(int c)
    {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter
    {
        public boolean isSpaceChar(int ch);
    }
}

class MyPoint2D implements Comparable<MyPoint2D>
{
    public double x, y;
//    double theta;
    int id;
    public MyPoint2D(double x, double y, int id)
    {
        this.x = x;
        this.y = y;
//        theta = Math.atan2(y, x);
        this.id = id;
    }

    // compare by y-coordinate, breaking ties by x-coordinate
    public int compareTo(MyPoint2D that)
    {
        if (this.y < that.y)
            return -1;
        if (this.y > that.y)
            return +1;
        if (this.x < that.x)
            return -1;
        if (this.x > that.x)
            return +1;
        return 0;
    }

    /*
    returns cross of vectors p1->p2 and p2->p3
     */
    public static double cross(MyPoint2D p1, MyPoint2D p2, MyPoint2D p3)
    {
        //using cross product of vectors p1p2 and p2p3
        //cross product will only have z component

        //vector a = p2-p1, b = p3-p2
        double ax = p2.x - p1.x;
        double ay = p2.y - p1.y;
        double bx = p3.x - p2.x;
        double by = p3.y - p2.y;

        //z compont of cross
        double crossZ = ax * by - bx * ay;
        return crossZ;
    }

    // compare other points relative to polar angle (between -pi and pi) they
    // make with Origin, break ties with y then x

    //sort by id

    // does this point equal y?
    public boolean equals(Object other)
    {
        if (other == this)
            return true;
        if (other == null)
            return false;
        if (other.getClass() != this.getClass())
            return false;
        MyPoint2D that = (MyPoint2D) other;
        return this.x == that.x && this.y == that.y;
    }

    // convert to string
    public String toString()
    {
        return "(" + x + ", " + y + ")";
    }

    }