#include <bits/stdc++.h>
#define rep(i,j,k) for(int i=(j);i<=(k);i++)
#define per(i,j,k) for(int i=(j);i>=(k);i--)
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define db double
#define ldb long double
#define pii pair<int,int>
#define pll pair<ll,ll>
#define mkp make_pair
#define eb emplace_back
#define SZ(S) (int)S.size()
//#define mod 998244353
#define mod 1000000007
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3f
using namespace std;

template <class T>
void chkmax(T &x,T y){
    if(x < y) x = y;
}

template <class T>
void chkmin(T &x,T y){
    if(x > y) x = y;
}

inline int popcnt(int x){
    return __builtin_popcount(x);
}

inline int ctz(int x){
    return __builtin_ctz(x);
}

template <int P>
class mod_int
{
    using Z = mod_int;

private:
    static int mo(int x) { return x < 0 ? x + P : x; }

public:
    int x;
    int val() const { return x; }
    mod_int() : x(0) {}
    template <class T>
    mod_int(const T &x_) : x(x_ >= 0 && x_ < P ? static_cast<int>(x_) : mo(static_cast<int>(x_ % P))) {}
    bool operator==(const Z &rhs) const { return x == rhs.x; }
    bool operator!=(const Z &rhs) const { return x != rhs.x; }
    Z operator-() const { return Z(x ? P - x : 0); }
    Z pow(long long k) const
    {
        Z res = 1, t = *this;
        while (k)
        {
            if (k & 1)
                res *= t;
            if (k >>= 1)
                t *= t;
        }
        return res;
    }
    Z &operator++()
    {
        x < P - 1 ? ++x : x = 0;
        return *this;
    }
    Z &operator--()
    {
        x ? --x : x = P - 1;
        return *this;
    }
    Z operator++(int)
    {
        Z ret = x;
        x < P - 1 ? ++x : x = 0;
        return ret;
    }
    Z operator--(int)
    {
        Z ret = x;
        x ? --x : x = P - 1;
        return ret;
    }
    Z inv() const { return pow(P - 2); }
    Z &operator+=(const Z &rhs)
    {
        (x += rhs.x) >= P && (x -= P);
        return *this;
    }
    Z &operator-=(const Z &rhs)
    {
        (x -= rhs.x) < 0 && (x += P);
        return *this;
    }
    Z operator-()
    {
        return -x;
    }
    Z &operator*=(const Z &rhs)
    {
        x = 1ULL * x * rhs.x % P;
        return *this;
    }
    Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
#define setO(T, o)                                  \
    friend T operator o(const Z &lhs, const Z &rhs) \
    {                                               \
        Z res = lhs;                                \
        return res o## = rhs;                       \
    }
    setO(Z, +) setO(Z, -) setO(Z, *) setO(Z, /)
#undef setO
    
    friend istream& operator>>(istream& is, mod_int& x)
    {
        long long tmp;
        is >> tmp;
        x = tmp;
        return is;
    }
    friend ostream& operator<<(ostream& os, const mod_int& x)
    {
        os << x.val();
        return os;
    }
};

using Z = mod_int<mod>;
Z power(Z p,ll k){
    Z ans = 1;
    while(k){
        if(k % 2 == 1) ans *= p;
        p *= p;
        k /= 2;
    }
    return ans;
}
int N,M,n,m;
int A[300005],B[300005],a[300005],b[300005],sum[300005];
Z ans[300005],output[300005];

const Z i2 = Z(1) / 2;
Z C2(int v){
    return Z(v) * (v + 1) * i2;
}
Z _eval(int v){
    v = max(0,min(v,M + 1) - 1);
    return Z(M + 1) * v - Z(v) * (v + 1) * i2;
}

int sz;
int c[300005],d[300005];
void add(){
//    printf("add\n");
    rep(i,1,sz) c[i]++;
}

void psh(int val,int r){
    ++sz;
    c[sz] = val;d[sz] = r;
}

Z eval(){
    Z res = 0;
    rep(i,1,sz) res += _eval(c[i]) * d[i];
/*    printf("eval:");
    rep(i,1,sz) printf("(%d,%d) ",c[i],d[i]);
    printf("->%d\n",res.val());*/
    return res;
}

Z calc(int L,int k){
    if(L < 0) return 0;
    Z ret = 0;
    for(int p = k,i = 1;p <= L;p += k,i++){
        ret += C2(L - p + 1) * _eval(i);
        if(p + k <= L) ret -= C2(L - p - k + 1) * _eval(i);
    }
    return ret;
}

vector <int> S,SS;
void solver(){
    S.clear();
    rep(i,1,n){
        sum[i] = sum[i - 1] + a[i];
        S.eb(i);
    }
    int cur,temp;
    rep(k,1,N + M - 1){
//        printf("solver k=%d\n",k);
        sz = 0;
        psh(0,1);
        int q = 0;
        for(int i:S){
            ans[k + 1] += eval() * (sum[i - 1] - sum[q]);
            psh(0,sum[i - 1] - sum[q]);
            ans[k + 1] += eval();
            cur = 1;
            while(cur + k <= a[i]){
                cur += k;
                ans[k + 1] += k * eval();
                add();
            }    
            ans[k + 1] += (a[i] - cur) * eval();
//            printf("seg %d cur=%d\n",i,ans[k + 1].val());

            psh(0,1);
            cur = 1;temp = 0;
            while(cur + k <= a[i]){
                psh(temp,k);
                cur += k;temp++;
            }
            psh(temp,a[i] - cur);
            ans[k + 1] += calc(a[i] - 3,k);

            q = i;
            if(a[i] >= k) SS.eb(i);
        }
        ans[k + 1] += eval() * (sum[n] - sum[q] + 1);
        swap(S,SS);
        SS.clear();
    }
}

int main(){
//    freopen("test.in","r",stdin);
//    freopen("test.out","w",stdout);
    scanf("%d%d",&N,&M);
    rep(i,1,N) scanf("%d",&A[i]);
    rep(i,1,M) scanf("%d",&B[i]);
    for(int l = 1,r;l < N;l = r){
        r = l + 1;
        while(r < N && 1ll * (A[r + 1] - A[r]) * (A[r] - A[r - 1]) > 0) r++;
        a[++n] = r - l;
    }   
    for(int l = 1,r;l < M;l = r){
        r = l + 1;
        while(r < M && 1ll * (B[r + 1] - B[r]) * (B[r] - B[r - 1]) > 0) r++;
        b[++m] = r - l;
    }       
/*    printf("array a:\n");
    rep(i,1,n) printf("%d ",a[i]);
    printf("\n");*/
    Z cof = C2(N) * C2(M);
    rep(k,2,N + M) output[k] = cof;
    solver();
    rep(k,2,N + M){
//        printf("%d ",ans[k].val());
        output[k] -= ans[k]; 
        ans[k] = 0;
    }
//    printf("\n");

//    return 0;
    swap(N,M);swap(n,m);
    rep(i,1,n) swap(a[i],b[i]);
    solver();
    rep(k,2,N + M){
//        printf("%d ",ans[k].val());
        output[k] -= ans[k]; 
        ans[k] = 0;
    }
//    printf("\n");

    per(i,N + M,1) output[i] -= output[i - 1];
    rep(i,1,N + M) printf("%d ",output[i].val());
	return 0;
}