#include <bits/stdc++.h>
using namespace std;

namespace SOL {

using i64 = long long;
void debug(const char *msg, ...) {
#ifdef CLESIP
    va_list arg;
    static char pbString[512];
    va_start(arg,msg);
    vsprintf(pbString,msg,arg);
    cerr << "[DEBUG] " << pbString << "\n";
    va_end(arg);
#endif    
}
template<typename T, typename L>
bool chkmax(T &x, L y) { if (x < y) return x = y, true; return false; }
template<typename T, typename L>
bool chkmin(T &x, L y) { if (y < x) return x = y, true; return false; }

const int N = 3e5 + 10;
const i64 P = 1e9 + 7;
const i64 inv2 = (P + 1) / 2;
int n, m, arr[N], b[N];
i64 ans[N * 2], sum[3][N];
vector<array<int, 2>> vec;

void mod(i64 &x, i64 y) {
	x += y;
	if (x >= P)
		x -= P;
}

i64 calc_val(int t) {
	i64 tmp = min(t - 1, m);
	return tmp * (2 * m - tmp + 1) / 2 % P;
}

void calc(int x) {
	vector<int> pt;
	pt.push_back(0);
	for (auto [l, r] : vec) {
		int pos = l + x;
		while (pos <= r)
			pt.push_back(pos), pos += x;
	}
	int cnt = pt.size() - 1;
	pt.push_back(n + 1);
	for (int i = 1; i <= cnt; i ++) {
		i64 coef = pt[i + 1] - pt[i];
		sum[0][i] = sum[0][i - 1], sum[1][i] = sum[1][i - 1], sum[2][i] = sum[2][i - 1];
		mod(sum[0][i], coef);
		mod(sum[1][i], coef * i % P);
		mod(sum[2][i], coef * i % P * i % P);
	}
	int j = 0, lst = 0;
	for (int t = 0; t < (int) vec.size(); t ++) {
		auto [l, r] = vec[t];
		vector<int> cur;
		cur.push_back(0);
		int pos = r - x;
		while (pos >= l)
			cur.push_back(pos), pos -= x;
		while (j <= cnt && pt[j] <= r)
			j ++;
		int tot = cur.size() - 1;
		cur.push_back(lst);
		for (int i = 1; i <= tot && i <= m; i ++) {
			i64 coef = cur[i] - cur[i + 1];
			// 0 add
			{
				i64 other = pt[j] - r - 1;
				mod(ans[x], coef * other % P * calc_val(i));
			}
			if (i < m) {
				int to = min(cnt, j + m - i - 1);
				i64 sum0 = (sum[0][to] - sum[0][j - 1] + P) % P;
				i64 sum1 = (sum[1][to] - sum[1][j - 1] + 2 * P - sum0 * (j - 1) % P) % P;
				i64 sum2 = (sum[2][to] - sum[2][j - 1] - sum0 * (j - 1) % P * (j - 1) % P - sum1 * 2 % P * (j - 1) % P + 3 * P) % P;
				i64 c0 = coef;
				i64 c1 = c0 * i % P;
				i64 c2 = c1 * i % P; 
				i64 val = (
					(2 * m + 1) * sum1 % P * c0 % P
					+ (2 * m + 1) * sum0 % P * c1 % P
					- sum2 * c0 % P
					- c2 * sum0 % P
					- 2 * sum1 % P * c1 % P
					+ 3 * P
				) % P * inv2 % P;
				mod(ans[x], val);
			}
		}
		// in block
		i64 coef = l - lst - 1;
		for (int i = 1; l + i * x <= r; i ++) {
			int L = l + i * x, R = min(r, l + i * x + x - 1);
			mod(ans[x], 1ll * (R - L + 1) * 
					calc_val(i) % P * coef % P);
		}
		lst = r - x;
	}
}

void work() {
	for (int i = 1; i <= n; i ++)
		cin >> arr[i];
	for (int i = 1; i < n; i ++)
		b[i] = (arr[i] < arr[i + 1]);
	for (int i = 1; i < n; i ++) {
		int j = i;
		while (j + 1 < n && b[j + 1] == b[j])
			j += 1;
		vec.push_back({ i, j });
		i = j;
	}
	for (auto [_l, _r] : vec) {
		int len = _r - _l;
		for (int x = 1; x < len; x ++) {
			for (int j = 1 + x, i = 1; j <= len; j += x, i ++) {
				int l = j, r = min(len, j + x - 1);
				mod(ans[x], 1ll * (1ll * (r - l + 1) * (m - l + 1 + m - r + 1) / 2 % P) * 
					calc_val(i) % P);			
			}
		}
	}
	for (int x = 1; x < n; x ++) {
		vector<array<int, 2>> nxt;
		for (auto [l, r] : vec)
			if (r - l >= x)
				nxt.push_back({ l, r });
		swap(nxt, vec);
		calc(x);
	}
}

void solve() {
	cin >> n >> m;
	work();
	swap(n, m);
	work();
	ans[0] = (1ll * n * (n + 1) / 2 % P) * (1ll * m * (m + 1) / 2 % P) % P;
	cout << 0 << " ";
	for (int i = 0; i < n + m - 1; i ++)
		cout << (ans[i] - ans[i + 1] + P) % P << " \n"[i + 1 == n + m];
}

}
int main() {
	ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
	SOL::solve();
	return 0;
}