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: class Mint:
      MOD = 1000000007  # Must be a prime
      CACHE_FACTORIALS = [1, 1]
  
      def __init__(self, v):
          if self.__isally(v):
              self.v = v.v % self.MOD
          else:
              self.v = v % self.MOD
  
      @property
      def inv(self):
          return Mint(self.__minv(self.v))
  
      @classmethod
      def factorial(cls, v):
          for i in range(len(cls.CACHE_FACTORIALS), int(v) + 1):
              cls.CACHE_FACTORIALS.append(cls.CACHE_FACTORIALS[-1] * i % cls.MOD)
          return Mint(cls.CACHE_FACTORIALS[int(v)])
  
      @classmethod
      def perm(cls, n, r):
          if n < r or r < 0:
              return 0
          return cls.factorial(n) // cls.factorial(n - r)
  
      @classmethod
      def comb(cls, n, r):
          if n < r or r < 0:
              return 0
          return cls.perm(n, r) // cls.factorial(r)
  
      @classmethod
      def __isally(cls, v) -> bool:
          return isinstance(v, cls)
  
      @classmethod
      def __minv(cls, v) -> int:
          return pow(v, cls.MOD - 2, cls.MOD)
  
      @classmethod
      def __mpow(cls, v, w) -> int:
          return pow(v, w, cls.MOD)
  
      def __str__(self):
          return str(self.v)
  
      __repr__ = __str__
  
      def __int__(self):
          return self.v
  
      def __eq__(self, w):
          return self.v == w.v if self.__isally(w) else self.v == w
  
      def __add__(self, w):
          return Mint(self.v + w.v) if self.__isally(w) else Mint(self.v + w)
  
      __radd__ = __add__
  
      def __sub__(self, w):
          return Mint(self.v - w.v) if self.__isally(w) else Mint(self.v - w)
  
      def __rsub__(self, u):
          return Mint(u.v - self.v) if self.__isally(u) else Mint(u - self.v)
  
      def __mul__(self, w):
          return Mint(self.v * w.v) if self.__isally(w) else Mint(self.v * w)
  
      __rmul__ = __mul__
  
      def __floordiv__(self, w):
          return (
              Mint(self.v * self.__minv(w.v))
              if self.__isally(w)
              else Mint(self.v * self.__minv(w))
          )
  
      def __rfloordiv__(self, u):
          return (
              Mint(u.v * self.__minv(self.v))
              if self.__isally(u)
              else Mint(u * self.__minv(self.v))
          )
  
      def __pow__(self, w):
          return (
              Mint(self.__mpow(self.v, w.v))
              if self.__isally(w)
              else Mint(self.__mpow(self.v, w))
          )
  
      def __rpow__(self, u):
          return (
              Mint(self.__mpow(u.v, self.v))
              if self.__isally(u)
              else Mint(self.__mpow(u, self.v))
          )
  
  
  n, m = map(int, input().split())
  x = [int(s) for s in input().split()]
  y = [int(s) for s in input().split()]
  dx = [x[i + 1] - x[i] for i in range(n - 1)]
  dy = [y[i + 1] - y[i] for i in range(m - 1)]
  dp = [Mint(0)] * n
  for i, d in enumerate(dx):
      dp[i + 1] = dp[i] + (i + 1) * d
  sx = sum(dp)
  dp = [Mint(0)] * m
  for i, d in enumerate(dy):
      dp[i + 1] = dp[i] + (i + 1) * d
  sy = sum(dp)
  print(sx * sy)
  
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"}]