#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef std::pair<long long, long long> P;
typedef std::priority_queue<P, std::vector<P>, std::greater<P>> PQ;
typedef std::complex<double> cd;

struct P3 {
    long long first, second, third;
};

struct P4 {
    long long first, second, third, fourth;
};

struct P3P {
    P first, second, third;
};

struct compP3{
    bool operator()(const P3 &p1,const P3 &p2) const {
        if (p1.first != p2.first) return p1.first < p2.first;
        if (p1.second != p2.second) return p1.second < p2.second;
        else return p1.third < p2.third;
    }
};

struct gcompP3{
    bool operator()(const P3 &p1,const P3 &p2) const {
        if (p1.first != p2.first) return p1.first > p2.first;
        if (p1.second != p2.second) return p1.second > p2.second;
        else return p1.third > p2.third;
    }
};

struct comp{
    bool operator()(const P3 &p1,const P3 &p2) const {
        ll a = p1.first + p1.third;
        ll b = p2.first + p2.third;
        return a < b;
    }
};

const double PI = acos(-1.0);

bool ckran(int a, int n) {
    return (a >= 0 && a < n);
}

void yn (bool f) {
    if (f) std::cout << "Yes" << '\n';
    else std::cout << "No" << '\n';
}

void zo (bool f) {
    if (f) std::cout << 1 << '\n';
    else std::cout << 0 << '\n';
}

long long sclog10(long long n) {
    long long ans = 0;
    while (n != 0) {
        n /= 10;
        ans++;
    }
    return ans;
}

long long longpow(long long x, long long n) {
    long long ans = 1;
    for (long long i = 0; i < n; ++i) {
        ans *= x;
    }
    return ans;
}

long long pplus(P a) {
    return a.first + a.second;
}

long long pminus(P a) {
    return a.first - a.second;
}

long long ptime(P a) {
    return a.first * a.second;
}

long long pdiv(P a) {
    return a.first / a.second;
}

std::pair<long long, long long> unzip(long long x, long long m) {
    std::pair<long long, long long> res;
    res.first = x / m;
    res.second = x % m;
    return res;
}

template<typename T, typename U>
bool chmax(T& a, U b) {
    if (a < b) {
        a = b;
        return true;
    } else {
        return false;
    }
}

template<typename T, typename U>
bool chmin(T& a, U b) {
    if (a > b) {
        a = b;
        return true;
    } else {
        return false;
    }
}

int main()
{
    ll h, w;
    cin >> h >> w;
    vector<ll> a(h), b(w);
    ll mi = 0, mx = 0;
    ll mod = 1e9 + 7;
    for (int i = 0; i < h; ++i) {
        cin >> a[i];
        mi += a[i];
    }
    mi %= mod;
    for (int i = 0; i < w; ++i) {
        cin >> b[i];
    }
    sort(a.begin(), a.end());
    sort(b.begin(), b.end());
    assert(a.back() != 1000000000);
    ll cur = 0;
    for (int i = 0; i < h; ++i) {
        while (cur < w && b[cur] < a[i]) {
            mx += b[cur] * (h - i);
            mx %= mod;
            mi += b[cur];
            mi %= mod;
            cur++;
        }
        mx += a[i] * (w - cur);
        if (a[i] == b[cur]) {
            mx += b[cur] * (h - i - 1);
            cur++;
        }
        mx %= mod;
        if (i == h - 1) {
            while (cur < w) {
                mi += b[cur];
                mi %= mod;
                cur++;
            }
        }
    }
    cout << mi << endl << mx << endl;
}