// Arup Guha
// 11/12/2020
// Solution to 2013 SER D1 Problem: Triangles

// Note: I watched David Harmeyer's Video on how to solve this before implementing it
//       and used the technique he described.

import java.util.*;

public class triangles {

	public static int n;
	public static point[] list;
	public static int[] map;
	public static ArrayList<event> events;

	public static void main(String[] args) {
	
		Scanner stdin = new Scanner(System.in);
		n = stdin.nextInt();
		
		// Process cases.
		while (n != 0) {
		
			// Read in points.
			list = new point[n];
			for (int i=0; i<n; i++) {
				int x = stdin.nextInt();
				int y = stdin.nextInt();
				list[i] = new point(x, y, i);
			}
			
			// Create each swap event.
			events = new ArrayList<event>();
			for (int i=0; i<n; i++) {
				for (int j=i+1; j<n; j++) {
					if (list[i].compareTo(list[j]) < 0) 
						events.add(new event(i, j, list[j].x-list[i].x, list[j].y-list[i].y));
					else
						events.add(new event(j, i, list[i].x-list[j].x, list[i].y-list[j].y));
				}
			}
			
			// These must be sorted.
			Collections.sort(events);
			
			// Sort by x to begin.
			Arrays.sort(list);
			
			// Store where each original index is now located.
			map = new int[n];
			for (int i=0; i<n; i++)
				map[list[i].ID] = i;
				
			// Initial answers to be overwritten.
			long min = 1000000000, max = 0;
			
			// Process each event.
			for (int i=0; i<events.size(); i++) {
			
				// Find where points are for the relevant segment.
				int idx1 = map[events.get(i).ID1];
				int idx2 = map[events.get(i).ID2];
				
				// Find adjacent points in current sorting for min triangle with this base.
				int prev = Math.min(idx1,idx2)-1;
				int next = Math.max(idx1, idx2)+1;
				
				// Update min.
				if (prev >= 0) min = Math.min(min, dArea(idx1, idx2, prev));
				if (next < n) min = Math.min(min, dArea(idx1, idx2, next));
				
				// Update max.
				if (Math.min(idx1,idx2) > 0) max = Math.max(max, dArea(idx1, idx2, 0));
				if (Math.max(idx1,idx2) < n-1) max = Math.max(max, dArea(idx1, idx2, n-1));
				
				// Swap these two locations!
				int tmp = map[events.get(i).ID1];
				map[events.get(i).ID1] = map[events.get(i).ID2];
				map[events.get(i).ID2] = tmp;
				
				// swap in array list.
				point mytmp = list[idx1];
				list[idx1] = list[idx2];
				list[idx2] = mytmp;
			}
			
			// Output the result.
			output(min);
			System.out.print(" ");
			output(max);
			System.out.println();
			
			// Get next case.
			n = stdin.nextInt();
		}
	}
	
	public static long dArea(int i, int j, int k) {
	
		// Get two vectors of triangle.
		long dx1 = list[j].x - list[i].x;
		long dy1 = list[j].y - list[i].y;
		long dx2 = list[k].x - list[i].x;
		long dy2 = list[k].y - list[i].y;
		
		// Cross Product Magnitude is double the triangle area.
		return Math.abs(dx1*dy2-dx2*dy1);
	}
	
	// Outputs half of val with exactly 1 decimal point.
	public static void output(long val) {
		if (val%2 == 0)
			System.out.print((val/2)+".0");
		else
			System.out.print((val/2)+".5");
	}
}

// Stores a point to sort by x then y.
class point implements Comparable<point> {

	public long x;
	public long y;
	public int ID;
	
	public point(int myx, int myy, int myid) {
		x = myx;
		y = myy;
		ID = myid;
	}
	
	public int compareTo(point other) {
		if (x < other.x) return -1;
		if (x > other.x) return 1;
		if (y < other.y) return -1;
		if (y > other.y) return 1;
		return 0;
	}
}

// Stores an swapping event. (vX, vY) is the vector and ID1, ID2 are the original IDs.
class event implements Comparable<event> {

	public int ID1;
	public int ID2;
	public long vX;
	public long vY;
	
	public event(int first, int second, long x, long y) {
		ID1 = first;
		ID2 = second;
		vX = x;
		vY = y;
	}
	
	// This correctly handles sorting my vectors from -90 to +90.
	public int compareTo(event other) {
		long cross = this.vX*other.vY - this.vY*other.vX;
		if (cross < 0) return -1;
		if (cross > 0) return 1;
		return 3000*ID1 + ID2 - (3000*other.ID1 + other.ID2);
	}
}