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.List;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Set;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.util.HashSet;
import java.util.Collections;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		FastScanner in = new FastScanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskB solver = new TaskB();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskB {
    public void solve(int testNumber, FastScanner in, PrintWriter out) {
		int n = in.nextInt();
		int maxFlipped = n / 2;
		int[] w = new int[n];
		int[] h = new int[n];
		Set<Integer> all = new HashSet<>();
		for (int i = 0; i < n; i++) {
			w[i] = in.nextInt();
			h[i] = in.nextInt();
			all.add(w[i]);
			all.add(h[i]);
		}
		int ans = Integer.MAX_VALUE;
		outer:
		for (int maxH : all) {
			int sumW = 0;
			int flipped = 0;
			List<Integer> deltas = new ArrayList<>();
			for (int i = 0; i < n; i++) {
				if (h[i] > maxH) {
					++flipped;
					if (w[i] > maxH) {
						continue outer;
					}
					sumW += h[i];
				} else {
					sumW += w[i];
					if (w[i] <= maxH) {
						deltas.add(h[i] - w[i]);
					}
				}
			}
			if (flipped > maxFlipped) {
				continue;
			}
			Collections.sort(deltas);
			for (int delta : deltas) {
				if (delta >= 0) {
					break;
				}
				if (flipped + 1 <= maxFlipped) {
					++flipped;
					sumW += delta;
				}
			}
			ans = Math.min(ans, sumW * maxH);
		}
		out.println(ans);
    }
}

class FastScanner {

	private BufferedReader in;
	private StringTokenizer st;

	public FastScanner(InputStream stream) {
		in = new BufferedReader(new InputStreamReader(stream));
	}

	public String next() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(in.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return st.nextToken();
	}

	public int nextInt() {
		return Integer.parseInt(next());
	}

}

