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 b {
public static void main(String[] args)
{
    Scanner input = new Scanner(System.in);
    int n = input.nextInt();
    int[] ws = new int[n], hs = new int[n];
    for(int i = 0; i<n; i++)
    {
        ws[i] = input.nextInt();
        hs[i] = input.nextInt();
    }
    int min = 1987654321;
    for(int h = 1; h<=1000; h++)
    {
        int w = 0;
        boolean valid = true;
        ArrayList<Integer> canSave = new ArrayList<Integer>();
        int lying = 0;
        for(int i = 0; i<n; i++)
        {
            if(ws[i] > h && hs[i] > h)
            {
                valid = false;
                break;
            }
            else if(ws[i] > h)
            {
                w += ws[i];
                
            }
            else if(hs[i] > h)
            {
                lying++;
                w += hs[i];
            }
            else
            {
                w += ws[i];
                if(hs[i] < ws[i]) canSave.add(ws[i] - hs[i]);
            }
        }
        Collections.sort(canSave);
        if(lying > n/2) valid = false;
        if(!valid) continue;
        for(int i = 0; i<n/2 - lying && i < canSave.size(); i++) w -= canSave.get(canSave.size() - 1 - i);
        min = Math.min(min, h*w);
    }
    System.out.println(min);

}
}
