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.*;
import java.util.*;
import java.math.*;

import static java.lang.Math.*;

public class solution implements Runnable {
	
	class Point implements Comparable<Point> {
		public double x, y;
		
		public Point() {
			x = y = 0.0;
		}
		
		public Point(double x, double y) {
			this.x = x;
			this.y = y;
		}
		
		public int compareTo(Point p) {
			if (abs(this.x - p.x) < 1E-9) {
				if (abs(this.y - p.y) < 1E-9)
					return 0;
				else {
					if (this.y - p.y > 0.0)
						return 1;
					else
						return -1;
				}
			}
			if (this.x - p.x > 0.0)
				return 1;
			else
				return -1;
		}
	}
	
	public double vmul(Point p, Point p1, Point p2) {
		return (p1.x - p.x) * (p2.y - p.y) - (p1.y - p.y) * (p2.x - p.x); 
	}
	
	public void solve() throws Exception {
		int n = sc.nextInt();
		Point p[] = new Point[n];
		for (int i = 0; i < n; i++) {
			p[i] = new Point(sc.nextDouble(), sc.nextDouble());				
		}
		double ans = 0.0;
		for (int i = 0; i < n; i++) {
			for (int j = i + 1; j < n; j++) {
				double s1 = 0.0;
				double s2 = 0.0;
				for (int k = 0; k < n; k++) {
					if (i == k || j == k)
						continue;
					if (vmul(p[i], p[j], p[k]) > 1E-9)
						s1 = max(s1, vmul(p[i], p[j], p[k]) * .5);
					if (vmul(p[i], p[j], p[k]) < -1E-9)
						s2 = max(s2, abs(vmul(p[i], p[j], p[k]) * .5));
				}
				if (s1 > 1E-9 && s2 > 1E-9)
					ans = max(ans, s1 + s2);
			}
		}
		out.format("%.10f%n", ans);
	}
	
	static Throwable throwable;
	
	BufferedReader in;
	FastScanner sc;
	PrintWriter out;
	
	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			sc = new FastScanner(in);
			solve();
		} catch (Throwable throwable) {
			solution.throwable = throwable;
		} finally {
			out.close();
		}		
	}
	
	public static void main(String[] args) throws Throwable {
		Thread thread = new Thread(null, new solution(), "", (1 << 26));
		thread.start();
		thread.join();
		if (solution.throwable != null)
			throw throwable;
	}
	
}

class FastScanner {
	BufferedReader reader;
	StringTokenizer str;
	
	public FastScanner(BufferedReader re) {
		this.reader = re;
	}
	
	public String nextToken() throws Exception {
		while (str == null || !str.hasMoreTokens()) {
			str = new StringTokenizer(reader.readLine());
		}
		return str.nextToken();
	}
	
	public int nextInt() throws Exception {
		return Integer.parseInt(nextToken());
	}
	
	public long nextLong() throws Exception {
		return Long.parseLong(nextToken());
	}
	
	public double nextDouble() throws Exception {
		return Double.parseDouble(nextToken());
	}
}