#include "bits/stdc++.h"
using namespace std;
#define all(x) x.begin(),x.end()
template<typename A, typename B> ostream& operator<<(ostream &os, const pair<A, B> &p) { return os << p.first << " " << p.second; }
template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> ostream& operator<<(ostream &os, const T_container &v) { string sep; for (const T &x : v) os << sep << x, sep = " "; return os; }
#ifdef LOCAL
#include "debug.h"
#else
#define debug(...) 42
#define ASSERT(...) 42
#endif
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pi;
const int oo = 1e9;
/*
for A with some monotonic sequences.
A, B look at bigger of the two?
Can always split to the optimum plus 1.
So best is <= (N/M)+1
Assume N>=M
small edge cases are trashy
2 is doable usually?
1 | 2 | 3
?
1 3 2 4
If string lengths are roughly equal?
a a a b a b
(if you know max s is something?)
You can keep it the same.
if becomes too much:

a a a bad?
a<a<b bad?
a<b>a>a bad?
a<b>a>b bad?
So the best you can do
a a a a a a a a a > b < a?
currently have:
binary search on answer s.
then do dp[i][j][flag] = min current length of monotonic in a direction.

Ok, observation, given lengths N>=M
can add some < or > sign inside N for 1 cost, max cost<=M
What is minimum number of adjacent <<<< signs or >>>> signs?
For a given string: can binary search on s-1 = number of signs, and check it by greedily adding the signs?
If <<<<<< (too many signs), can add > at regular intervals and not at the ends, you need ceil(B/s) signs.
So total number of cost needed is sum of ceil((BLOCK_i)/s)<=M.
So for some s to be optimal you have:  sum ceil((BLOCK_i)/s)<=M < sum ceil((BLOCK_i)/(s-1)).
For some s to be >= optimum? 
You need: sum ceil((BLOCK_i)/s)<=M

And you need: sum from (m-M+1) to N
This is easy to work with?

If you do divide and conquer:
substrings that go over the splitting line: 
s < sqrt(n) ? Can loop over them
s > sqrt(n) Only O(sqrt(n)) segments are important.
I would just like to now all floor((Block_i-1)/s) as a frequency array.
only have O(n/s) important segments, res of the segments contribute 0!.
rest of the segments just contribute something flat.
Want to know contributions of weight1* p_j - p_i*weight2, but only when p_j>p_i
Can do it with a single FFT!
ok, so have important and stupid segments.
stupid segments: can group them together.
can do some FFT?
want to know frequencies of those
Afterwards:
For given s:
now the amount of those?
Can just calc that easily, and subtract with <=(s+1)
inside block need to be careful.
need to subtract those again...
in total <= 3e5*3e5, so can easily fit with regular FFT.
*/
const long long MD = 1e9+7;
template<long long MOD=MD> struct mdint {
    int d;
    mdint () {d=0;}
    mdint (long long _d) : d(_d%MOD){
        if(d<0) d+=MOD;
    };
    friend mdint& operator+=(mdint& a, const mdint& o) {
        a.d+=o.d; if(a.d>=MOD) a.d-=MOD;
        return a;
    }
    friend mdint& operator-=(mdint& a, const mdint& o) {
        a.d-=o.d; if(a.d<0) a.d+=MOD;
        return a;
    }
    friend mdint& operator*=(mdint& a, const mdint& o) {
        return a = mdint((ll)a.d*o.d);
    }
    mdint operator*(const mdint& o) const {
        mdint res = *this;
        res*=o;
        return res;
    }
    mdint operator+(const mdint& o) const {
        mdint res = *this;
        res+=o;
        return res;
    }
    mdint operator-(const mdint& o) const {
        mdint res = *this;
        res-=o;
        return res;
    }
    mdint operator^(long long b) const {
        mdint tmp = 1;
        mdint power = *this;
        while(b) {
            if(b&1) {
                tmp = tmp*power;
            }
            power = power*power;
            b/=2;
        }
        return tmp;
    }
    friend mdint operator/=(mdint& a, const mdint& o) {
        a *= (o^(MOD-2));
        return a;
    }
    mdint operator/(const mdint& o) {
        mdint res = *this;
        res/=o;
        return res;
    }
    bool operator==(const mdint& o) { return d==o.d;}
    bool operator!=(const mdint& o) { return d!=o.d;}
    friend istream& operator>>(istream& c, mdint& a) {return c >> a.d;}
    friend ostream& operator<<(ostream& c, const mdint& a) {return c << a.d;}
};
using  mint = mdint<MD>;
vector<bool> read(int n) {
    vi a(n);
    for(auto& i : a) cin >> i;
    vector<bool> b(n-1);
    for(int i=0;i<n-1;++i) b[i] = a[i]<a[i+1];
    return b;
}
vector<mint> solve(vector<bool> a, int m) {
    int n = a.size();
    // first write n^4!
    vector<mint> ans(n+1); // s<=k, for all k
    for(int len=2;len<=min(n+1,m);++len) {
        for(int olen=len;olen<=m;++olen) {
            ans[0]+=(n+1-len+1)*ll(m-olen+1);
        }
    }
    for(int s=1;s<=n;++s) { // answer is <=s
        mint res=0;
        for(int i=0;i<n;++i) {
            int need=0;
            int cur=1;
            for(int j=i;j<n;++j) {
                if(j>i and a[j]==a[j-1]) cur++;
                else {
                    need+=(cur-1)/s;
                    cur=1;
                }
                int need2 = need + (cur-1)/s;
                // assume substring ends here!
                for(int len=max(1,need2);len<=m;++len) {
                    res+=(m-len+1);
                }
            }

        }
        ans[s]=res;

    }
    // s=k --> s<=k and s>k-1
    for(int i=ans.size()-1;i>0;--i) ans[i]-=ans[i-1];
    ans.erase(ans.begin());
    return ans;
    


}
mint arith(ll a, ll b) {
    if(a>b) return 0;
    return (a+b)*(b-a+1)/2;
}
const mint inv2 = mint(1)/2;
vector<mint> solve2(vector<bool> a, int m) {
    int n = a.size();
    // first write n^4!
    vector<mint> ans(n+1); // s<=k, for all k
    for(int len=2;len<=min(n+1,m);++len) {
        ans[0]+=arith(1,m-len+1)*(n+1-len+1);
    }
    struct B {
        int l;
        int mid;
        int r;
    };
    vector<B> blocks;
    for(int i=0;i<n;) {
        int j = i;
        while(j<n and a[i]==a[j]) ++j;
        blocks.push_back({0,j-i,0});
        i=j;
    }
    for(int s=1;s<=n;++s) { // answer is <=s
        if(!blocks.empty()) {
            vector<B> nb; nb.reserve(blocks.size());
            int freebefore = blocks[0].l;
            for(auto b : blocks) {
                if(b.mid<=s) {
                    freebefore+=b.mid;
                    freebefore+=b.r;
                } else {
                    b.l = freebefore;
                    nb.push_back(b);
                    freebefore = b.r;
                }
            }
            
            if(!nb.empty()) nb.back().r=freebefore;
            for(int i=1;i<nb.size();++i) {
                nb[i-1].r=nb[i].l;
            }
            swap(nb,blocks);
        }
        mint res=0;
        if(blocks.empty()) {
            // all subarrays are good?
            res = arith(1,n)*arith(1,m);
        } else {
            // do it faster!
            mint zeros=0;
            typedef array<mint,3> W;
            vector<W> prefsums = {{}};
            int lastpref=0;
            auto addL = [&](mint num, int mypref) {
                assert(mypref>=lastpref);
                while(lastpref<mypref) {
                    prefsums.push_back(prefsums.back());
                    ++lastpref;
                }
                W nls = {num,num*mypref,num*mypref*mypref};
                auto& ls = prefsums.back();
                for(int i=0;i<3;++i) ls[i]+=nls[i];

            };
            auto addC = [&](mint num, int sum) {
                if(sum==0) zeros+=num;
                res+=num*arith(1,m+1-sum);
            };
            auto addR = [&](mint num, int mypref) {
                W rs = {num,num*mypref,num*mypref*mypref};
                assert(mypref>=lastpref);
                if(mypref==lastpref) {
                    mint cur = prefsums[mypref][0];
                    if(mypref) cur-=prefsums[mypref-1][0];
                    zeros+=cur*num;
                }
                auto ls = prefsums.back();
                int bef = mypref - m-1;
                if(bef>lastpref) return;
                if(bef>=0) {
                    for(int j=0;j<3;++j) ls[j]-=prefsums[bef][j];
                }
                auto contribution = ls[2]*rs[0]*inv2 - ls[1]*rs[1] + ls[1]*rs[0]*(inv2*3+m);
                contribution+=ls[0]*rs[2]*inv2 - rs[1]*ls[0]*(inv2*3+m) + ls[0]*rs[0]*(mint(m)*(m+3)*inv2 + 1);
                res+=contribution; 
            };

            /*
            do just arith(1,m+1-(pb-pa)) =
            Problem when pb-pa>
            a (a/2 - b + m + 3/2) + b (b/2 - m - 3/2) + (m/2 + 3/2) m + 1
            
            and for all 0's do something special?
            */
            int pref=0;
            // in all blocks, inside: 
            // loop over the sum
            // for this sum do the addition manually
            for(auto b : blocks) {
                

                // only strictly inside
                // add the ls.
                addC(arith(1,b.l),0);
                addL(b.l, pref);
                for(int sum=0;sum<=(b.mid-1)/s;++sum) {
                    // strictly inside:
                    int lo = max(1,(sum*s+1)), hi = min(b.mid,(sum+1)*s);
                    mint num = hi-lo+1;
                    if(lo<=hi)
                    addR(num,pref+sum);
                }
                
                for(int sum=0;sum<=(b.mid-1)/s;++sum) {
                    int lo = max(1,(sum*s+1)), hi = min(b.mid,(sum+1)*s);
                    if(lo<=hi) {
                        addC(arith(b.mid+1-hi,b.mid+1-lo),sum);
                    }
                }
                pref+=(b.mid-1)/s;
                for(int sum=(b.mid-1)/s;sum>=0;--sum) {
                    int lo = max(1,sum*s+1), hi = min(b.mid,(sum+1)*s);
                    mint num = hi-lo+1;
                    if(lo<=hi)
                    addL(num,pref-sum);
                }
                addR(b.r,pref);
            }
            addC(arith(1,blocks.back().r), 0);
            res+=zeros*(arith(1,m)-arith(1,m+1));
        //     mint brute=0;
        //     for(int i=0;i<n;++i) {
        //         int need=0;
        //         int cur=1;
        //         for(int j=i;j<n;++j) {
        //             if(j>i and a[j]==a[j-1]) cur++;
        //             else {
        //                 need+=(cur-1)/s;
        //                 cur=1;
        //             }
        //             int need2 = need + (cur-1)/s;
        //             // assume substring ends here!
        //             // need2,1 ? 
        //             brute+=arith(1, m-max(need2,1)+1);
        //         }

        //     }
        //     debug(brute,res);
        //     if(brute!=res) exit(0);
            
        }
        
        ans[s]=res;

    }
    // s=k --> s<=k and s>k-1
    for(int i=ans.size()-1;i>0;--i) ans[i]-=ans[i-1];
    ans.erase(ans.begin());
    return ans;
    


}
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int n,m; cin >> n >> m;
    auto a = read(n), b = read(m);
    vector<mint> ans(n+m);
    auto res = solve2(a,m);
    for(int i=0;i<res.size();++i) {
        ans[i]+=res[i];
    }
    res = solve2(b,n);
    for(int i=0;i<res.size();++i) {
        ans[i]+=res[i];
    }
    for(int len=1;len<=min(n,m);++len) {
        // for all with this length, answer is 2:
        ans[0]+=mint(n-len+1)*(m-len+1);
    }
    ans.insert(ans.begin(),0);
    // ans.push_back(0);
    ans.pop_back();
    // assert(ans.size()==n+m);
    cout << ans << ' ' << '\n';

}