output_description: Print the maximum possible score of a'.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      a_1 a_2 ... a_{3N}
attempt: import sys
  
  readline = sys.stdin.readline
  MOD = 10**9 + 7
  INF = float("INF")
  sys.setrecursionlimit(10**5)
  
  import heapq
  
  
  class PriorityQueue:
      class Reverse:
          def __init__(self, val):
              self.val = val
  
          def __lt__(self, other):
              return self.val > other.val
  
          def __repr__(self):
              return repr(self.val)
  
      def __init__(self, x=None, desc=False):
          if not x:
              x = []
          if desc:
              for i in range(len(x)):
                  x[i] = self.Reverse(x[i])
          self._desc = desc
          self._container = x
          heapq.heapify(self._container)
  
      @property
      def is_empty(self):
          return not self._container
  
      def pop(self):
          if self._desc:
              return heapq.heappop(self._container).val
          else:
              return heapq.heappop(self._container)
  
      def push(self, item):
          if self._desc:
              heapq.heappush(self._container, self.Reverse(item))
          else:
              heapq.heappush(self._container, item)
  
      def top(self):
          if self._desc:
              return self._container[0].val
          else:
              return self._container[0]
  
      def sum(self):
          return sum(self._container)
  
      def __len__(self):
          return len(self._container)
  
  
  def main():
      n = int(readline())
      a = list(map(int, readline().split()))
  
      first = a[:n]
      second = a[n : 2 * n]
      third = a[2 * n : 3 * n]
  
      first_max = [0] * (n + 1)
      third_min = [0] * (n + 1)
  
      first_max[0] = sum(first)
      third_min[0] = sum(third)
  
      pq_first = PriorityQueue(first)
      cur = first_max[0]
      for i, x in enumerate(second, 1):
          if pq_first.top() < x:
              cur -= pq_first.pop()
              cur += x
              pq_first.push(x)
          first_max[i] = cur
  
      pq_third = PriorityQueue(third, desc=True)
      cur = third_min[0]
      for i, x in enumerate(second[::-1], 1):
          if pq_third.top() > x:
              cur -= pq_third.pop()
              cur += x
              pq_third.push(x)
          third_min[i] = cur
  
      ans = -INF
      for i in range(n):
          fi_idx = i
          th_idx = n - i
          ans = max(ans, first_max[fi_idx] - third_min[th_idx])
  
      print(ans)
  
  
  if __name__ == "__main__":
      main()
  
problem_description: 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'.
samples: [{"input": "2\n    3 1 4 1 5 9", "output": "1\n    \n\nWhen a_2 and a_6 are removed, a' will be (3, 4, 1, 5), which has a score of (3\n+ 4) - (1 + 5) = 1.\n\n* * *"}, {"input": "1\n    1 2 3", "output": "-1\n    \n\nFor example, when a_1 are removed, a' will be (2, 3), which has a score of 2 -\n3 = -1.\n\n* * *"}, {"input": "3\n    8 2 2 7 4 6 5 3 8", "output": "5\n    \n\nFor example, when a_2, a_3 and a_9 are removed, a' will be (8, 7, 4, 6, 5, 3),\nwhich has a score of (8 + 7 + 4) - (6 + 5 + 3) = 5."}]