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.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;


public class b {
    public static void main(String[] args) throws IOException{
        in.init(System.in);
        Vec2[] input = new Vec2[in.nextInt()];
        for (int i = 0; i < input.length; ++i){
            input[i] = new Vec2(in.nextInt(),in.nextInt());
        }
        
        Vec2[] points = convexHull(input);
        
        //System.out.println(Arrays.toString(input));
        //System.out.println(Arrays.toString(points));
        
        System.out.println(solve(((points.length==3)?input:points)));
    }
    
    public static double solve(Vec2[] points){
        double best = 0;
        
        // pick all combos of two
        for (int i = 0; i < points.length; ++i){
            for (int j = i + 1; j < points.length; ++j){
                double tri1 = 0, tri2 = 0, cur = 0;
                for (int k = 0; k < points.length; ++k){
                    if (k!=i && k != j){
                        cur = Vec2.triArea(points[i],points[j],points[k]);
                        
                        //System.out.println(cur);
                        
                        if (points[j].sub(points[i]).cross(points[j].sub(points[k])) > 0){
                            
                            
                            if (cur > tri1){
                                tri1 = cur;
                            }
                        }
                        else{
                            if (cur > tri2){
                                tri2 = cur;
                            }
                        }
                    }
                }
                
                if (tri1+tri2>best && tri1 != 0 && tri2 != 0)
                    best = tri1+tri2;
            }
        }
        
        return best;
    }
    
    public static Vec2[] convexHull(Vec2[] points) {
        ArrayList<Vec2> ans = new ArrayList<Vec2>();
        Vec2 min = points[0];

        // Get start point
        for (Vec2 p : points) {
            if (p.getY() < min.getY() || (p.getY() == min.getY() && p.getX() < min.getX())) {
                min = p;
            }
        }
        ans.add(min);

        // Build convex hull
        while (true) {
            Vec2 p = ans.get(ans.size() - 1), q = p;
            for (Vec2 r : points) {
                Vec2 pq = q.sub(p), pr = r.sub(p);
                double turn = pq.cross(pr);

                if (0 < turn || (0 == turn && pr.mag() > pq.mag())) {
                    q = r;
                }
            }

            if (q.equals(ans.get(0))) {
                return ans.toArray(new Vec2[ans.size()]);
            }
            ans.add(q);
        }
    }
    
    public static class Vec2 {

        private double x, y;

        public Vec2(double x, double y) {
            this.x = x;
            this.y = y;
        }
        
        public static double getArea(Vec2 p1, Vec2 p2, Vec2 p3, Vec2 p4){
            return triArea(p1,p2,p3) + triArea(p1,p3,p4);
        }
        
        public static double triArea(Vec2 p1, Vec2 p2, Vec2 p3){
            Vec2 side1 = p2.sub(p1);
            Vec2 side2 = p3.sub(p1);
            return .5*side1.mag()*side2.mag()*Math.sin(side1.angle(side2));
        }

        public double getX() {
            return x;
        }

        public double getY() {
            return y;
        }

        public void setX(double x) {
            this.x = x;
        }

        public void setY(double y) {
            this.y = y;
        }

        public boolean equals(Vec2 other) {
            return x == other.getX() && y == other.getY();
        }

        public double mag() {
            return Math.sqrt(x * x + y * y);
        }

        public double mag2() {
            return x * x + y * y;
        }

        public Vec2 scale(double scalar) {
            return new Vec2(scalar * x, scalar * y);
        }

        public Vec2 add(Vec2 other) {
            return new Vec2(x + other.getX(), y + other.getY());
        }

        public Vec2 sub(Vec2 other) {
            return new Vec2(x - other.getX(), y - other.getY());
        }

        public double dot(Vec2 other) {
            return x * other.getX() + y * other.getY();
        }
        
        public double angle(Vec2 other){
            return Math.acos(this.dot(other)/(this.mag() * other.mag()));
        }

        public double cross(Vec2 other) {
            return x * other.getY() - y * other.getX();
        }

        @Override
        public String toString() {
            return String.format("(%f, %f)", x, y);
        }
    }

    
    static class in {
        static BufferedReader reader;
        static StringTokenizer tokenizer;
        /** call this method to initialize reader for InputStream */
        static void init(InputStream input) {
            reader = new BufferedReader(new InputStreamReader(input));
            tokenizer = new StringTokenizer("");
        }
        /** get next word */
        static String next() throws IOException {
            while (!tokenizer.hasMoreTokens()) {
                // TODO add check for eof if necessary
                tokenizer = new StringTokenizer(reader.readLine());
            }
            return tokenizer.nextToken();
        }
        static int nextInt() throws IOException {
            return Integer.parseInt(next());
        }
        static double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }
        static long nextLong() throws IOException {
            return Long.parseLong(next());
        }
        static String nextLine() throws IOException {
            return reader.readLine();
        }
    }
}