The final exam is here, and it's now or never for Ethan. His current grade is
abysmal so he needs a strong showing on this exam to have any chance of
passing his introductory computer science class.

The exam has only one question: devise an algorithm to compute the compactness
of a grid tree.

Ethan recalls that a "grid tree" is simply an unweighted tree with 2**N**
nodes that you can imagine being embedded within a 2x**N** grid. The top row
of the grid contains the nodes 1 ... **N** from left to right, and the bottom
row of the grid contains the nodes (**N** \+ 1) ... 2**N** from left to right.
Every edge in a grid tree connects a pair of nodes which are adjacent in the
2x**N** grid. Two nodes are considered adjacent if either they're in the same
column, or they're directly side-by-side in the same row. There must be
exactly 2**N**-1 edges that connect the 2**N** nodes to form a single tree.
Additionally, the _i_th node in the grid tree is labelled with an integer
**Ai**.

What was "compactness" again? After some intense thought, Ethan comes up with
the following pseudocode to compute the compactness, **c**, of a grid tree:

  * 1\. Set **c** to be equal to 0. 
  * 2\. Iterate _i_ upwards from 1 to 2**N** \- 1: 
  * 2a. Iterate _j_ upwards from _i_+1 to 2**N**: 
  * 2b. Increase **c** by **Ai** * **Aj** * `ShortestDistance(i, j)`
  * 3\. Output **c**. 

`ShortestDistance(i, j)` is a function which returns the number of edges on
the shortest path from node _i_ to node _j_ in the tree, which Ethan has
implemented correctly. In fact, his whole algorithm is quite correct for once.
This is exactly how you compute compactness!

There's just one issue — in his code, Ethan has chosen to store **c** using a
rather small integer type, which is at risk of overflowing if **c** becomes
too large!

Ethan is so close! Feeling sorry for him, you'd like to make some last-minute
changes to the tree in order to minimize the final value of **c**, and thus
minimize the probability that it will overflow in Ethan's program and cost him
much-needed marks. You can't change any of the node labels **A1..2N**, but you
may choose your own set of 2**N** \- 1 edges to connect them into a grid tree.

For example, if **A** = [1, 3, 2, 2, 4, 5], then the grid of nodes looks like
this:

You'd like to determine the minimum possible compactness which Ethan's program
can produce given a valid tree of your choice. For example, one optimal tree
for the above grid of nodes (which results in the minimum possible compactness
of 198) is as follows:

### Input

Input begins with an integer **T**, the number of trees. For each tree, there
are three lines. The first line contains the single integer **N**. The second
line contains the **N** space-separated integers **A1..N**. The third line
contains the **N** space-separated integers **AN+1..2N**.

### Output

For the _i_th tree, output a line containing "Case #_i_: " followed by the
minimum possible output of Ethan's program.

### Constraints

1 ≤ **T** ≤ 80  
1 ≤ **N** ≤ 50  
1 ≤ **Ai** ≤ 1,000,000  

### Explanation of Sample

One optimal tree for the first case is given above. For that tree, Ethan's
program would compute **c** as the sum of the following values (with some
values omitted):

  * **A1** * **A2** * `ShortestDistance(1, 2)` = 1 * 3 * 1 = 3 
  * **A1** * **A3** * `ShortestDistance(1, 3)` = 1 * 2 * 4 = 8 
  * ... 
  * **A1** * **A6** * `ShortestDistance(1, 6)` = 1 * 5 * 3 = 15 
  * **A2** * **A3** * `ShortestDistance(2, 3)` = 3 * 2 * 3 = 18 
  * ... 
  * **A4** * **A6** * `ShortestDistance(4, 6)` = 2 * 5 * 2 = 20 
  * **A5** * **A6** * `ShortestDistance(5, 6)` = 4 * 5 * 1 = 20 

In the second case, there's only one possible tree, for which **c** = 2 * 3 *
1 = 6.

In the third case, two of the four possible trees are optimal (the ones
omitting either the topmost or leftmost potential edge).