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.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;

public class B {

    static void solve() throws IOException {
        int n = in.nextInt();
        int[] w = new int[n];
        int[] h = new int[n];
        for ( int i = 0; i < n; i ++ ) {
            w[i] = in.nextInt();
            h[i] = in.nextInt();
        }
        for ( int i = 0; i < n; i ++ ) {
            for ( int j = i + 1; j < n; j ++ ) {
                if ( h[i] > h[j] || ( ( h[i] == h[j] ) && ( w[i] - h[i] < w[j] - h[j] ) ) ) {
                    int t = h[i];
                    h[i] = h[j];
                    h[j] = t;
                    t = w[i];
                    w[i] = w[j];
                    w[j] = t;
                }
            }
        }
        int r = Integer.MAX_VALUE;
        for ( int H = 1; H <= 1000; H ++ ) {
            int W = 0;
            boolean ok = true;
            int[] d = new int[n];
            int dl = 0;
            int turn = 0;
            for ( int i = 0; i < n; i ++ ) {
                if ( h[i] > H && w[i] > H ) {
                    ok = false;
                    break;
                }
                if ( h[i] > H && w[i] <= H ) {
                    turn ++;
                    W += h[i];
                    if ( turn * 2 > n ) {
                        ok = false;
                        break;
                    }
                } else {
                    W += w[i];
                    if ( h[i] <= H && w[i] <= H ) {
                        d[dl ++] = h[i] - w[i];
                    }
                }
            }
            if ( !ok ) {
                continue;
            }
            Arrays.sort( d, 0, dl );
            for ( int i = 0; i < dl; i ++ ) {
                turn ++;
                if ( turn * 2 > n ) {
                    break;
                }
                if ( d[i] > 0 ) {
                    break;
                }
                W += d[i];
            }
            r = Math.min( r, W * H );
        }
        out.println( r );
    }

    static Scanner in;
//    static StreamTokenizer in;
    static PrintWriter out;

//    static int nextInt() throws IOException {
//        in.nextToken();
//        return ( int ) in.nval;
//    }

    public static void main( String[] args ) throws IOException {
        in = new Scanner( System.in );
//        in = new StreamTokenizer( new InputStreamReader( System.in ) );
        out = new PrintWriter( System.out );
        solve();
        out.close();
    }
}
