#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vii = vector<vector<int>>;
using viii = vector<vector<vector<int>>>;
using vl = vector<ll>;
using vll = vector<vector<ll>>;
using vlll = vector<vector<vector<ll>>>;
using vc = vector<char>;
using vcc = vector<vector<char>>;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
ll mod = ll(1e9) + 7;
ll inf = ll(1e18);
void bl(bool b, ostream& out = cout) { out << (b ? "Yes" : "No") << endl; }
void bl2(bool b, ostream& out = cout) { out << (b ? "YES" : "NO") << endl; }
template <typename T>
inline bool chmax(T& a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
inline bool chmin(T& a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
int dx[] = {1, 0, -1, 0, 1, -1, 1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, -1, 1};
using namespace std;
namespace dbg {
using ll = long long;
class Debug {
  void prefix() {
    cout << "\033[7m\033[35m"
         << " DEBUG "
         << "\033[0m" << endl;
  }
  void out_helper() { cout << endl; }
  void out_with_name_helper() { cout << endl; }
  template <typename T1, typename... T2>
  void out_helper(T1 v, T2... args);
  template <typename T1, typename... T2>
  void out_with_name_helper(string s, T1 v, T2... args);
  template <typename T>
  void print(T val);
  template <typename A, typename B>
  void print(pair<A, B> p);
  template <typename A, typename B, typename C>
  void print(tuple<A, B, C> t);
  template <typename T>
  void print(vector<T>& vec);
  template <typename T>
  void print(set<T>& st);
  template <typename A, typename B>
  void print(map<A, B> mp);

 public:
  Debug() {}
  template <typename... T>
  void out(T... args) {
    prefix();
    out_helper(args...);
  }
  template <typename... T>
  void out_with_name(T... args) {
    prefix();
    out_with_name_helper(args...);
  }
  template <typename T>
  void outg(vector<vector<T>>& g) {
    prefix();
    for (auto& v1 : g) {
      for (auto& v2 : v1) {
        cout << v2 << " ";
      }
      cout << endl;
    }
  }
};
template <typename T1, typename... T2>
void Debug::out_helper(T1 v, T2... args) {
  print(v);
  cout << endl;
  out_helper(args...);
}
template <typename T1, typename... T2>
void Debug::out_with_name_helper(string s, T1 v, T2... args) {
  cout << s << ": ";
  print(v);
  cout << endl;
  out_with_name_helper(args...);
}
template <typename T>
void Debug::print(T val) {
  cout << val;
}
template <typename A, typename B>
void Debug::print(pair<A, B> p) {
  cout << "(";
  print(p.first);
  cout << ", ";
  print(p.second);
  cout << ")";
}
template <typename A, typename B, typename C>
void Debug::print(tuple<A, B, C> t) {
  cout << "(";
  print(get<0>(t));
  cout << ", ";
  print(get<1>(t));
  cout << ", ";
  print(get<2>(t));
  cout << ")";
}
template <typename T>
void Debug::print(vector<T>& vec) {
  cout << "[";
  bool fir = true;
  for (auto& e : vec) {
    if (!fir) cout << " ";
    print(e), fir = false;
  }
  cout << "]";
}
template <typename T>
void Debug::print(set<T>& st) {
  cout << "{";
  bool fir = true;
  for (auto& e : st) {
    if (!fir) cout << " ";
    print(e), fir = false;
  }
  cout << "}";
}
template <typename A, typename B>
void Debug::print(map<A, B> mp) {
  cout << "{";
  bool fir = true;
  for (auto& p : mp) {
    if (!fir) cout << " ";
    print(p), fir = false;
  }
  cout << "}";
}
}  // namespace dbg
dbg::Debug debug;
namespace mint {
using ll = long long;
class Mint {
 public:
  ll v;
  ll mod;
  Mint(ll v = 0, ll mod = ll(1e9) + 7) : mod(mod), v((v % mod + mod) % mod) {}
  friend ostream& operator<<(ostream& os, const Mint& val) {
    os << val.v;
    return os;
  }
  Mint operator-() const { return Mint(-v); }
  Mint operator+(const Mint rhs) const {
    Mint res(*this);
    return res += rhs;
  }
  Mint operator-(const Mint rhs) const {
    Mint res(*this);
    return res -= rhs;
  }
  Mint operator*(const Mint rhs) const {
    Mint res(*this);
    return res *= rhs;
  }
  Mint& operator+=(const Mint rhs) {
    if ((v += rhs.v) >= mod) v -= mod;
    return *this;
  }
  Mint& operator-=(const Mint rhs) {
    if ((v += mod - rhs.v) >= mod) v -= mod;
    return *this;
  }
  Mint& operator*=(const Mint rhs) {
    (v *= rhs.v) %= mod;
    return *this;
  }
  Mint pow(ll t) const {
    if (!t) return 1;
    Mint b = pow(t >> 1);
    b *= b;
    if (t & 1) b *= *this;
    return b;
  }
  Mint inv() const { return pow(mod - 2); }
  Mint& operator/=(const Mint rhs) { return (*this) *= rhs.inv(); }
  Mint operator/(const Mint rhs) const {
    Mint res(*this);
    return res /= rhs;
  }
};
}  // namespace mint
using mint::Mint;
class D {
 public:
  void solve(std::istream& in, std::ostream& out) {
    int n, m;
    in >> n >> m;
    vl x(n), y(m);
    for (int i = 0; i < n; i++) in >> x[i];
    for (int i = 0; i < m; i++) in >> y[i];
    sort(x.begin(), x.end());
    sort(y.begin(), y.end());
    vector<Mint> xv(n);
    for (int i = 1; i < n; i++) {
      xv[i] = Mint(x[i] - x[i - 1]) * Mint(y[1] - y[0]);
      xv[i] *= (i * (n - i));
    }
    for (int i = 1; i < n; i++) xv[i] += xv[i - 1];
    vector<Mint> yv(m);
    yv[1] = xv[n - 1];
    for (int i = 2; i < m; i++) {
      yv[i] = yv[i - 1] / Mint(y[i - 1] - y[i - 2]);
      yv[i] *= Mint(y[i] - y[i - 1]);
    }
    for (int i = 1; i < m; i++) yv[i] *= (i * (m - i));
    for (int i = 1; i < m; i++) yv[i] += yv[i - 1];
    out << yv[m - 1] << endl;
  }
};
int main() {
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  D solver;
  std::istream& in(std::cin);
  std::ostream& out(std::cout);
  solver.solve(in, out);
  return 0;
}
