Problem:
Score : 500 points

Problem 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.

Constraints

2 \leq n,m \leq 10^5

-10^9 \leq x_1 < ... < x_n \leq 10^9

-10^9 \leq y_1 < ... < y_m \leq 10^9

x_i and y_i are integers.

Input

Input is given from Standard Input in the following format:

n m
x_1 x_2 ... x_n
y_1 y_2 ... y_m

Output

Print the total area of the rectangles, modulo 10^9+7.

Sample Input 1

3 3
1 3 4
1 3 6

Sample Output 1

60

The following figure illustrates this input:

The total area of the nine rectangles A, B, ..., I shown in the following figure, is 60.

Sample Input 2

6 5
-790013317 -192321079 95834122 418379342 586260100 802780784
-253230108 193944314 363756450 712662868 735867677

Sample Output 2

835067060

Solution in C++14 (GCC 5.4.1) (judge verdict: Time Limit Exceeded)

#include <iostream>
#include <string>
#include <vector>
#include <utility>
#include <map>
#include <algorithm>

using namespace std;

const int R = 1000000007;

long sum(const vector<int>& xs, const vector<int>& ys, int x1, int x2, int y1, int y2) {
  long dx = xs[x2] - xs[x1];
  long dy = ys[y2] - ys[y1];
  return (dx * dy) % R;
  // return all % R;
}

void dump(int x, int y)
{
  vector<vector<int>> grid(x, vector<int>(y, 0));
  for (int ix = 0; ix < x; ++ix) {
    for (int iy = 0; iy < y; ++iy) {
      for (int dx = 0; ix + dx < x; ++dx) {
        for (int dy = 0; iy + dy < y; ++dy) {
          for (int idx = 0; idx <= dx; ++idx) {
            for (int idy = 0; idy <= dy; ++idy) {
              ++grid[ix + idx][iy + idy];
            }
          }
        }
      }
    }
  }

  for (int ix = 0; ix < x; ++ix) {
    for (int iy = 0; iy < y; ++iy) {
      cout << grid[ix][iy] << " ";
    }
    cout << endl;
  }
}

int times(int x, int y, int xi, int yi)
{
  // cerr << x << ", " << y << ", " << xi << ", " << yi << endl;
  int nx = xi * (x - xi + 1);
  int ny = yi * (y - yi + 1);
  return nx * ny;
}

int main()
{
  int n, m;
  cin >> n >> m;
  vector<int> xs(n);
  vector<int> ys(m);
  for (int i = 0; i < n; ++i) cin >> xs[i];
  for (int i = 0; i < m; ++i) cin >> ys[i];

  long total = 0;
  int xsize = xs.size() - 1;
  int ysize = ys.size() - 1;
  for (int x = 1; x < xs.size(); ++x) {
    for (int y = 1; y < ys.size(); ++y) {
      long dx = xs[x] - xs[x - 1];
      long dy = ys[y] - ys[y - 1];
      long area = (dx * dy) % R;
      long m = times(xsize, ysize, x, y) % R;
      // cerr << x << ", " << y << ": " << m << endl;
      total += area * m;
      total %= R;
      /*
      for (long mi = 0; mi < m; ++mi) {
        total += area;
        total %= R;
      }
      */
    }
  }
  cout << total << endl;
  return 0;
}