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

public class CF529B {
    public static void main (String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int[] w = new int[n];
        int[] h = new int[n];
        for (int i = 0; i < n; ++i) {
            w[i] = scan.nextInt();
            h[i] = scan.nextInt();
        }
        int ans = -1;
        for (int H = 1; H <= 1000; ++H) {
            int W = 0, rem = (int)n/2, ok = 1;
            List<Integer> delta = new ArrayList<>();;
            for (int i = 0; i < n; ++i) {
                if (h[i] > H && w[i] > H) { // failed either way
                    ok = 0;
                    break;
                }
                else if (h[i] > H) { // && w[i] <= H // must lie down
                    W += h[i];
                    --rem;
                }
                else if (w[i] <= H) { // && h[i] <= H // can lie down
                    W += w[i];
                    delta.add(h[i] - w[i]);
                }
                else { // w[i] > H && h[i] <= H // cannot lie down
                    W += w[i];
                }
            }
            if (ok == 0 || rem < 0)
                continue;
            Collections.sort(delta); // sort by possible reduction in width
            for (int d : delta) { // lie down the first rem people
                if (--rem < 0 || d > 0)
                    break;
                W += d;
            }
            if (W*H < ans || ans == -1)
                ans = W*H;
        }
        System.out.println(ans);
    }
}