#include <bits/stdc++.h>
using std::bitset;
using std::cerr;
using std::cin;
using std::cout;
using std::deque;
using std::endl;
using std::fill;
using std::fixed;
using std::ios_base;
using std::iterator;
using std::map;
using std::max_element;
using std::min_element;
using std::multimap;
using std::multiset;
using std::pair;
using std::queue;
using std::reverse;
using std::set;
using std::setprecision;
using std::sort;
using std::stable_sort;
using std::stack;
using std::string;
using std::swap;
using std::unique;
using std::vector;
long long min(long long a, long long b) { return a < b ? a : b; }
long long min(int a, long long b) { return a < b ? a : b; }
long long min(long long a, int b) { return a < b ? a : b; }
long long min(int a, int b) { return a < b ? a : b; }
long long max(long long a, long long b) { return a > b ? a : b; }
long long max(int a, long long b) { return a > b ? a : b; }
long long max(long long a, int b) { return a > b ? a : b; }
long long max(int a, int b) { return a > b ? a : b; }
namespace MySpace {};
struct Node {
  int x, y;
  long long summ;
  int sz;
  Node *L, *R;
};
Node *NewNode(int x) {
  Node *R = new Node();
  R->summ = x;
  R->x = x;
  R->y = (1 << 15) * rand() + rand();
  R->sz = 1;
  return R;
}
void describe(Node *Nd) {
  if (!Nd) return;
  describe(Nd->L);
  cout << Nd->x << " ";
  describe(Nd->R);
}
int get_sz(Node *Nd) {
  if (Nd) return Nd->sz;
  return 0;
}
long long get_summ(Node *Nd) {
  if (Nd) return Nd->summ;
  return 0;
}
long long update(Node *Nd) {
  Nd->summ = Nd->x + get_summ(Nd->L) + get_summ(Nd->R);
  Nd->sz = 1 + get_sz(Nd->L) + get_sz(Nd->R);
}
Node *Merge(Node *L, Node *R) {
  if (!L) return R;
  if (!R) return L;
  if (L->y < R->y) {
    L->R = Merge(L->R, R);
    update(L);
    return L;
  } else {
    R->L = Merge(L, R->L);
    update(R);
    return R;
  }
}
pair<Node *, Node *> Split(Node *Scope, int k) {
  if (!Scope) return {nullptr, nullptr};
  if (Scope->x <= k) {
    pair<Node *, Node *> a = Split(Scope->R, k);
    Scope->R = a.first;
    update(Scope);
    return {Scope, a.second};
  } else {
    pair<Node *, Node *> a = Split(Scope->L, k);
    Scope->L = a.second;
    update(Scope);
    return {a.first, Scope};
  }
}
pair<Node *, Node *> SplitSize(Node *Scope, int k) {
  if (!Scope) return {nullptr, nullptr};
  if (get_sz(Scope->L) < k) {
    pair<Node *, Node *> a = SplitSize(Scope->R, k - get_sz(Scope->L) - 1);
    Scope->R = a.first;
    update(Scope);
    return {Scope, a.second};
  } else {
    pair<Node *, Node *> a = SplitSize(Scope->L, k);
    Scope->L = a.second;
    update(Scope);
    return {a.first, Scope};
  }
}
void Add(Node *&Root, int x) {
  Node *Nd = NewNode(x);
  pair<Node *, Node *> a = Split(Root, x);
  a.first = Merge(a.first, Nd);
  Root = Merge(a.first, a.second);
}
long long n, m;
long long x[500000];
long long y[500000];
long long c = 0;
long long ans = 0;
const long long MOD = 1e9 + 7;
signed main() {
  srand(time(NULL));
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cin >> n >> m;
  for (int(i) = 0; (i) != (n); (i)++) cin >> x[i];
  for (int(j) = 0; (j) != (m); (j)++) cin >> y[j];
  for (int i = 0; i + 1 < n; i++)
    c += (x[i + 1] - x[i]) * (i + 1) * (n - i - 1), c %= MOD;
  for (int i = 0; i + 1 < m; i++)
    ans += c * (y[i + 1] - y[i]) * (i + 1) * (m - i - 1), c %= MOD;
  cout << ans;
}
