#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, vector<T> &v) {
  os << "{";
  for (int i = 0; i < (int)(v.size()); ++i)
    os << v[i] << (i == (int)v.size() - 1 ? "" : ", ");
  os << "}";
  return os;
}
template <typename T>
T dup(T x, T y) {
  return (x + y - 1) / y;
};
template <typename A, size_t N, typename T>
inline void arrayFill(A (&array)[N], const T &val) {
  std::fill((T *)array, (T *)(array + N), val);
}
struct in {
  const size_t n = 0;
  in() = default;
  in(size_t n) : n(n){};
  template <typename T>
  operator T() {
    T ret;
    cin >> ret;
    return ret;
  }
  template <typename T>
  operator vector<T>() {
    assert(n != 0);
    vector<T> ret(n);
    for (auto &x : ret) cin >> x;
    return ret;
  }
};
using ll = int64_t;
using vint = vector<int32_t>;
using vvint = vector<vint>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pint = pair<int32_t, int32_t>;
using pll = pair<ll, ll>;
using setint = set<int32_t>;
using setstr = set<string>;
using qint = queue<int32_t>;
using qpint = queue<pint>;
constexpr std::int32_t INF = 1001001001;
constexpr std::int64_t LINF = 1001001001001001001;
constexpr int mod = 1000000007;
class mint {
 private:
  std::int64_t m_x;

 public:
  mint(std::int64_t m_x = 0) : m_x(m_x % mod) {}
  std::int64_t get() { return m_x; }
  mint &operator+=(const mint a) {
    if ((m_x += a.m_x) >= mod) m_x -= mod;
    return *this;
  }
  mint &operator-=(const mint a) {
    if ((m_x += mod - a.m_x) >= mod) m_x -= mod;
    return *this;
  }
  mint &operator*=(const mint a) {
    (m_x *= a.m_x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res += a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res -= a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res *= a;
  }
  mint pow(const std::int64_t t) const {
    if (!t) return 1;
    mint a = pow(t >> 1);
    a *= a;
    if (t & 1) a *= *this;
    return a;
  }
  mint inv() const { return pow(mod - 2); }
  mint &operator/=(const mint a) { return (*this) *= a.inv(); }
  mint operator/(const mint a) const {
    mint res(*this);
    return res /= a;
  }
};
void Main() {
  ll n = in(), m = in();
  vll x = in(n), y = in(m);
  mint ans = 0;
  for (int i = 0; i < (int)(n - 1); ++i)
    for (int j = 0; j < (int)(m - 1); ++j) {
      mint s = (mint)(x[i + 1] - x[i]) * (y[j + 1] - y[j]);
      mint lt = (mint)(i + 1) * (j + 1);
      mint rb = (mint)(n - i - 1) * (m - j - 1);
      ans += s * lt * rb;
    }
  cout << ans.get() << endl;
}
int main() {
  std::cin.tie(nullptr);
  std::ios_base::sync_with_stdio(false);
  std::cout << std::fixed << std::setprecision(15);
  Main();
  return 0;
}
