import java.util.TreeMap

/**
 * (a'の前半N要素) first、取り除かれたN 個の要素 removed、(a'の後半N要素) last の3つに分かれる。
 * 仮にfirstが、aのm番目までに存在することがわかっているとすると、
 * (a'の前半N要素の総和)−(a'の後半N要素の総和)の最大値は
 * (aのm番目までのうち小さい方からm-N個を除いたものの総和) - (aのm番目よりも後の3N-m個のうち、大きい方から2N-m個を除いたものの総和)
 * となる。
 *
 * mが1増えると、
 *
 * (firstの総和)は、
 * aのm+1番目の要素分だけ増え、
 * firstに、aのm+1番目の要素を加えた集合の中の最小のものの分だけ、減少する。
 *
 * (lastの総和)は、
 * aのm+1番目の要素が、除かれる2N-m個に入っていた場合は、変化せず、
 * そうでない場合は、
 * aのm+1番目の要素の分だけ減り、
 * 除かれる2N-m個のうち最小のものの分だけ増える。
 *
 * mはNから2Nまで変化するので繰り返しはN+1回
 * 大小の探索は、木構造を使えばlogNで可能と思われ、
 * O(N logN)で可能か。
 */
fun main(args: Array<String>) {
    val n = readLine()!!.toInt()    // 1≤N≤10^5
    val a = readLine()!!.split(" ").map(String::toInt)      // 1≤ai≤10^9

    val first = a.take(n)//.sorted()
    val remain = a.takeLast(2 * n).sorted()
    val removed = remain.takeLast(n)       // 大きい方から2N-m個を除いた

    // mがNのときで初期化
    val firstPart = FirstPart(first)
    val removedPart = RemovedPart(removed, remain.take(n))
    var result = firstPart.targetSum - removedPart.targetSum

    for (m in n .. n * 2 - 1) {     // コード上のmは0オリジン
        val e = a[m]
        firstPart.add(e)
        removedPart.remove(e)
        val score = firstPart.targetSum - removedPart.targetSum

        result = listOf(result, score).max()!!

    }
    println(result)
}


abstract internal class Part (list: List<Int>) {
    /** 値をkeyとして値がlistに含まれる回数を記録する。*/
    protected val data = TreeMap<Int, Int>()
    init {
        for (e in list) {
            this.data.increment(e)
        }
    }
    /** 目標とするものの総和。継承先により異なる。 */
    abstract var targetSum: Long      // intの上限を超えることあり。
        protected set

    /** dataにeの分を加える(+1する)*/
    protected fun MutableMap<Int, Int>.increment(e: Int) {
        this[e] = this.getOrElse(e, { 0 }) + 1
    }
    /**
     * dataからeの分を除く(-1する)
     * @param e 除く要素。dataのkeyに存在することは外部で保証すること。
     */
    protected fun MutableMap<Int, Int>.decrement(e: Int) {
        val count = this[e]!!   // 存在することは保証されている。

        if (count > 1) {
            this[e] = count - 1
        } else if (count == 1) {
            this.remove(e)
        } else {
            throw Exception("0個の要素をさらに除外しようとしました。")
        }
    }
}

/**
 * (aのm番目までのうち小さい方からm-N個を除いたものの総和)は、
 * aのm+1番目の要素分だけ増え、
 * aのm番目までのうち小さい方からm-N個を除いたもののに、aのm+1番目の要素を加えた集合の中の最小のものの分だけ、減少する。
 */
internal class FirstPart(list: List<Int>): Part(list) {
    override var targetSum = list.map { it.toLong() }.sum()

    /** first部分の処理 */
    fun add(e: Int) {
        if (data.firstKey() == e) {
            // eが最小(の一つ)であれば変化しない
            return
        } else {
            // eを加え、最小を除く
            val min = data.firstKey()

            this.data.decrement(min)
            this.data.increment(e)

            // 総和も調整
            this.targetSum += e - min
        }
    }
}

/**
 * (aのm番目よりも後の3N-m個のうち、大きい方から2N-m個を除いたものの総和)は、
 * aのm+1番目の要素が、除かれる2N-m個に入っていた場合は、変化せず、
 * そうでない場合は、
 * aのm+1番目の要素の分だけ減り、
 * 除かれる2N-m個のうち最小のものの分だけ増える。
 *
 * @param list: 取り除かれる要素のList
 * @param lastPart: 取り除かれない方のList
 */
internal class RemovedPart(list: List<Int>, lastPart: List<Int>): Part(list) {
    val last = mutableMapOf<Int, Int>()
    init {
        for (e in lastPart) {
            this.last.increment(e)
        }
    }
    /** ここではlastPart側の総和になる。 */
    override var targetSum = lastPart.map { it.toLong() }.sum()

    /** removed部分とlast部分の処理 */
    fun remove(e: Int) {
        if (e in this.data) {
            // aのm+1番目の要素が、除かれる2N-m個に入っていた場合は、変化せず
            // だが、dataからeは除かれる。
            this.data.decrement(e)
            return
        } else {
            // それ以外とはlastにeが入っているということ。
            // lastからeを除き、dataの最小を1つlastに移す。総和も変更する。
            this.last.decrement(e)

            val min = this.data.firstKey()
            this.data.decrement(min)
            this.last.increment(min)

            this.targetSum += min - e
        }
    }
}

