import java.io.{BufferedReader, InputStream, InputStreamReader}
import java.util.StringTokenizer

import scala.collection.mutable
import scala.util.Sorting
import math.{abs, max, min}
import scala.reflect.ClassTag

object Main {
  val MOD = 1000000007
  def solve(): Unit = {
    val sc = new InputReader(System.in)
    val N = sc.nextInt()

    val left = Array.fill[Long](N)(sc.nextLong())
    val leftT = new Heap[Long](N + 1)
    left.indices foreach (i => leftT.push(left(i)))
    val mid_right = Array.fill[Long](2 * N)(sc.nextLong())
    val mid = mid_right.take(N)

    Sorting.quickSort(mid_right)
    val rightT = new Heap[Long](N)
    val unusedRightT = new Heap[Long](N)
    (0 until N) foreach (i => rightT.push(mid_right(i)))
    (N until 2 * N) foreach (i => unusedRightT.push(mid_right(i)))

    var L: Long = ((0 until N) map (left(_))).sum
    var R: Long = ((0 until N) map (mid_right(_))).sum
    var ans: Long = L - R

    (0 until N) foreach { i =>
      val x = mid(i)

      // (y) (x) -> (x) ()
      leftT.push(x)
      L += x - leftT.pop()

      // (y) (x) -> () (y)
      if (rightT.remove(x)) {
        val y = unusedRightT.pop()
        rightT.push(y)
        R -= x - y
      } else {
        unusedRightT.remove(x)
      }

      ans = max(ans, L - R)
    }

    println(ans)
  }


  def main(args: Array[String]): Unit = {
    solve()
  }


  class InputReader(val stream: InputStream) {
    private val reader = new BufferedReader(new InputStreamReader(stream), 32768)
    private var tokenizer: StringTokenizer = null

    def next: String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new StringTokenizer(reader.readLine)
      tokenizer.nextToken
    }

    def nextInt(): Int = next.toInt
    def nextLong(): Long = next.toLong
    def nextChar(): Char = next.charAt(0)
  }

  class Heap[@specialized(Int, Long) A: ClassTag](size: Int)(implicit o: Ordering[A]) {
    private var n: Int = 0
    private val nodes = {
      val k = {
        var n = size
        var i = 0
        while(n > 0) {
          n >>= 1
          i += 1
        }
        i
      }
      Array.ofDim[A]((1 << k) - 1)
    }

    def push(x: A): Unit = {
      n += 1

      def step(i: Int): Int = {
        val p = (i - 1) / 2
        i match {
          case 0 => 0
          case _ if o.lteq(nodes(p), x) => i
          case _ =>
            nodes(i) = nodes(p) // 親を下ろす
            step(p)
        }
      }

      nodes(step(n - 1)) = x
    }

    def remove(x: A): Boolean = {
      val pos = findPos(x)
      if (pos == -1) false
      else {
        removeByPos(findPos(x))
        true
      }
    }

    def pop(): A = {
      val x = nodes(0)
      removeByPos(0)
      x
    }

    private def findPos(x: A): Int = {
      def step(i: Int): Int = {
        if (i >= n) -1
        else if (nodes(i) == x) i
        else {
          val pos = step(2 * i + 1)
          if (pos != -1) pos
          else step(2 * i + 2)
        }
      }
      step(0)
    }

    private def removeByPos(i: Int): Unit = {
      val x = nodes(n - 1)
      n -= 1

      def step(i: Int): Int = {
        val l = 2 * i + 1
        val r = 2 * i + 2
        if (l >= n) i
        else {
          val c = if (r >= n && o.lteq(nodes(r), nodes(l))) r else l
          if (o.lteq(x, nodes(c))) i
          else {
            nodes(i) = nodes(c)
            step(c)
          }
        }
      }

      nodes(step(i)) = x
    }

    def peek: A = nodes(0)
  }
}
