Many years have passed, and n friends met at a party again. Technologies have leaped forward since the last meeting, cameras with timer appeared and now it is not obligatory for one of the friends to stand with a camera, and, thus, being absent on the photo.

Simply speaking, the process of photographing can be described as follows. Each friend occupies a rectangle of pixels on the photo: the i-th of them in a standing state occupies a wi pixels wide and a hi pixels high rectangle. But also, each person can lie down for the photo, and then he will occupy a hi pixels wide and a wi pixels high rectangle.

The total photo will have size W × H, where W is the total width of all the people rectangles, and H is the maximum of the heights. The friends want to determine what minimum area the group photo can they obtain if no more than n / 2 of them can lie on the ground (it would be strange if more than n / 2 gentlemen lie on the ground together, isn't it?..)

Help them to achieve this goal.

Input

The first line contains integer n (1 ≤ n ≤ 1000) — the number of friends.

The next n lines have two integers wi, hi (1 ≤ wi, hi ≤ 1000) each, representing the size of the rectangle, corresponding to the i-th friend.

Output

Print a single integer equal to the minimum possible area of the photo containing all friends if no more than n / 2 of them can lie on the ground.

Examples

Input

3
10 1
20 2
30 3


Output

180


Input

3
3 1
2 2
4 3


Output

21


Input

1
5 10


Output

50
// practice with kaiboy
import java.io.*;
import java.util.*;

public class CF529B extends PrintWriter {
	CF529B() { super(System.out, true); }
	Scanner sc = new Scanner(System.in);
	public static void main(String[] $) {
		CF529B o = new CF529B(); o.main(); o.flush();
	}

	static final int H = 1000, INF = 0x3f3f3f3f;
	int[] ww, hh; Integer[] ii;
	int solve(int n, int h_) {
		int ans = 0, m = n / 2;
		for (int i = 0; i < n; i++) {
			int w = ww[i], h = hh[i];
			if (w > h_ && h > h_)
				return INF;
			if (h > h_) {
				ans += h;
				if (m-- == 0) 
					return INF;
			} else
				ans += w;
		}
		for (int i_ = 0; i_ < n && m > 0; i_++) {
			int i = ii[i_], w = ww[i], h = hh[i];
			if (h > h_ || w > h_ || w <= h)
				continue;
			ans -= w - h;
			m--;
		}
		return ans * h_;
	}
	void main() {
		int n = sc.nextInt();
		ww = new int[n];
		hh = new int[n];
		ii = new Integer[n];
		for (int i = 0; i < n; i++) {
			ww[i] = sc.nextInt();
			hh[i] = sc.nextInt();
			ii[i] = i;
		}
		Arrays.sort(ii, (i, j) -> (ww[j] - hh[j]) - (ww[i] - hh[i]));
		int ans = INF;
		for (int h_ = 1; h_ <= H; h_++)
			ans = Math.min(ans, solve(n, h_));
		println(ans);
	}
}
