output_description: Print the total area of the rectangles, modulo 10^9+7.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      n m
      x_1 x_2 ... x_n
      y_1 y_2 ... y_m
attempt: def getN():
      return int(input())
  
  
  def getNM():
      return map(int, input().split())
  
  
  def getList():
      return list(map(int, input().split()))
  
  
  def getArray(intn):
      return [int(input()) for i in range(intn)]
  
  
  def input():
      return sys.stdin.readline().rstrip()
  
  
  def rand_N(ran1, ran2):
      return random.randint(ran1, ran2)
  
  
  def rand_List(ran1, ran2, rantime):
      return [random.randint(ran1, ran2) for i in range(rantime)]
  
  
  def rand_ints_nodup(ran1, ran2, rantime):
      ns = []
      while len(ns) < rantime:
          n = random.randint(ran1, ran2)
          if not n in ns:
              ns.append(n)
      return sorted(ns)
  
  
  def rand_query(ran1, ran2, rantime):
      r_query = []
      while len(r_query) < rantime:
          n_q = rand_ints_nodup(ran1, ran2, 2)
          if not n_q in r_query:
              r_query.append(n_q)
      return sorted(r_query)
  
  
  from collections import defaultdict, deque, Counter
  from sys import exit
  from decimal import *
  import heapq
  from math import sqrt, pi
  from fractions import gcd
  import random
  import string
  import copy
  from itertools import combinations, permutations, product
  from operator import mul, itemgetter
  from functools import reduce
  from bisect import bisect_left, bisect_right
  
  import sys
  
  sys.setrecursionlimit(1000000000)
  mod = 10**9 + 7
  
  #############
  # Main Code #
  #############
  
  N, M = getNM()
  X = getList()
  Y = getList()
  
  X.sort(reverse=True)
  Y.sort(reverse=True)
  XP, YP = 0, 0
  for i in range(N):
      XP += (N - 1 - i * 2) * X[i]
      XP %= mod
  for i in range(M):
      YP += (M - 1 - i * 2) * Y[i]
      YP %= mod
  
  print((XP * YP) % mod)
  
problem_description: Statement
  
  On a two-dimensional plane, there are m lines drawn parallel to the x axis,
  and n lines drawn parallel to the y axis. Among the lines parallel to the x
  axis, the i-th from the bottom is represented by y = y_i. Similarly, among the
  lines parallel to the y axis, the i-th from the left is represented by x =
  x_i.
  
  For every rectangle that is formed by these lines, find its area, and print
  the total area modulo 10^9+7.
  
  That is, for every quadruple (i,j,k,l) satisfying 1\leq i < j\leq n and 1\leq
  k < l\leq m, find the area of the rectangle formed by the lines x=x_i, x=x_j,
  y=y_k and y=y_l, and print the sum of these areas modulo 10^9+7.
samples: [{"input": "3 3\n    1 3 4\n    1 3 6", "output": "60\n    \n\nThe following figure illustrates this input:\n\n![sample1-1](https://atcoder.jp/img/arc071/aec4d5cc2e5c73dbee455be237a649a5.png)\n\nThe total area of the nine rectangles A, B, ..., I shown in the following\nfigure, is 60.\n\n![sample1-2](https://atcoder.jp/img/arc071/f0771c0f7e68af2b00e7513186f585ff.png)\n\n* * *"}, {"input": "6 5\n    -790013317 -192321079 95834122 418379342 586260100 802780784\n    -253230108 193944314 363756450 712662868 735867677", "output": "835067060"}]