Problem:
Score : 500 points

Problem Statement

Let N be a positive integer.

There is a numerical sequence of length 3N, a = (a_1, a_2, ..., a_{3N}).
Snuke is constructing a new sequence of length 2N, a', by removing exactly N elements from a without changing the order of the remaining elements.
Here, the score of a' is defined as follows: (the sum of the elements in the first half of a') - (the sum of the elements in the second half of a').

Find the maximum possible score of a'.

Constraints

1 ≤ N ≤ 10^5

a_i is an integer.

1 ≤ a_i ≤ 10^9

Partial Score

In the test set worth 300 points, N ≤ 1000.

Input

Input is given from Standard Input in the following format:

N
a_1 a_2 ... a_{3N}

Output

Print the maximum possible score of a'.

Sample Input 1

2
3 1 4 1 5 9

Sample Output 1

1

When a_2 and a_6 are removed, a' will be (3, 4, 1, 5), which has a score of (3 + 4) - (1 + 5) = 1.

Sample Input 2

1
1 2 3

Sample Output 2

-1

For example, when a_1 are removed, a' will be (2, 3), which has a score of 2 - 3 = -1.

Sample Input 3

3
8 2 2 7 4 6 5 3 8

Sample Output 3

5

For example, when a_2, a_3 and a_9 are removed, a' will be (8, 7, 4, 6, 5, 3), which has a score of (8 + 7 + 4) - (6 + 5 + 3) = 5.

Solution in Pascal (FPC 2.6.2) (judge verdict: Wrong Answer)

Const   fi='';
        fo='';
Var     f:Text;
        n:Longint;
        A:Array[0..300000] of Longint;
        L1,L2:Array[0..300000] of Int64;
        Heapmin,Heapmax:Array[0..300000] of Longint;
        nheapmin,nheapmax:Longint;   sol:Int64;
Function max(i,j:Int64):Int64; Begin If i<j then Exit(j); Exit(i); End;
Procedure Inp;
Var     i:Longint;
Begin
        Assign(f,fi);   Reset(f);
        Read(f,n);
        For i:=1 to 3*n do Read(f,A[i]);
        Close(f);
End;
Procedure Swap(Var i,j:Longint);
Var     tg:Longint;
Begin
        tg:=i; i:=j; j:=tg;
End;
Procedure Upheapmin(x:Longint);
Begin
        If (x=1) or (A[Heapmin[x]]>=A[Heapmin[x div 2]]) then Exit
        Else Begin
                Swap(Heapmin[x],Heapmin[x div 2]);
                Upheapmin(x div 2);
        End;
End;
Procedure Downheapmin(x:Longint);
Var     vt:Longint;
Begin
        If (x>nheapmin div 2) then Exit;
        If (A[Heapmin[x*2]]>=A[Heapmin[x*2+1]]) and (x*2+1<=nheapmin) then vt:=x*2+1 Else vt:=x*2;
        If (A[Heapmin[x]]<=A[heapmin[vt]]) then Exit
        Else Begin
                Swap(heapmin[x],heapmin[vt]);
                Downheapmin(vt);
        End;
End;
Procedure Pushmin(x:Longint);
Begin
        Inc(nheapmin);
        heapmin[nheapmin]:=x;
        upheapmin(nheapmin);
End;
Procedure popmin(x:Longint);
Begin
        heapmin[1]:=x;
        downheapmin(1);
End;
Procedure Upheapmax(x:Longint);
Begin
        If (x=1) or (A[Heapmax[x]]<=A[Heapmax[x div 2]]) then Exit
        Else Begin
                Swap(Heapmax[x],Heapmax[x div 2]);
                Upheapmax(x div 2);
        End;
End;
Procedure Downheapmax(x:Longint);
Var     vt:Longint;
Begin
        If (x>nheapmax div 2) then Exit;
        If (A[Heapmax[x*2]]<=A[Heapmax[x*2+1]]) and (x*2+1<=nheapmax) then vt:=x*2+1 Else vt:=x*2;
        If (A[Heapmax[x]]>=A[heapmax[vt]]) then Exit
        Else Begin
                Swap(heapmax[x],heapmax[vt]);
                Downheapmax(vt);
        End;
End;
Procedure Pushmax(x:Longint);
Begin
        Inc(nheapmax);
        heapmax[nheapmax]:=x;
        upheapmax(nheapmax);
End;
Procedure popmax(x:Longint);
Begin
        heapmax[1]:=x;
        downheapmax(1);
End;
Procedure tongmax;
Var     i,j,k:Longint;
Begin
        k:=0;
        For i:=1 to n do
        Begin
                k:=k+A[i];
                Pushmin(i);
        End;
        L1[n]:=k;
        For i:=n+1 to 3*n do
        Begin
                If A[i]>A[heapmin[1]] then Begin L1[i]:=L1[i-1]-A[heapmin[1]]+A[i]; Popmin(i); End
                Else L1[i]:=L1[i-1];
        End;
End;
Procedure tongmin;
Var     i,j,k:Longint;
Begin
        k:=0;
        For i:=3*n downto 2*n+1 do
        Begin
                k:=k+A[i];
                Pushmax(i);
        End;
        L2[2*n+1]:=k;
        For i:=2*n downto 1 do
        Begin
                If A[i]<A[heapmax[1]] then Begin L2[i]:=L2[i+1]-A[heapmax[1]]+A[i]; Popmax(i); End
                Else L2[i]:=L2[i+1];
        End;
End;
Procedure Solve;
Var     i,j:Longint;
Begin
        tongmax;
        tongmin;
        sol:=-trunc(1e18);
        For i:=n to 2*n do sol:=max(sol,L1[i]-L2[i+1]);
        Assign(f,fo);   Rewrite(f);
        Write(f,sol);
        Close(f);
End;
BEGIN
        Inp;
        Solve;
END.