#include <bits/stdc++.h>
#include "horses.h"
using namespace std;
using i64 = long long;
constexpr int mod = 1e9 + 7;
struct SegmentTree {
int n;
vector<i64> t;
void init(int _n) {
n = _n;
t.resize(4 * n);
}
int merge(int x, int y) {
return (x * y) % mod;
}
void update(int id, int tl, int tr, int i, int v) {
if (tl == tr) {
t[id] = v;
return;
}
int x = (id << 1) + 1, y = x + 1, tm = (tl + tr) >> 1;
if (i <= tm) {
update(x, tl, tm, i, v);
} else {
update(y, tm + 1, tr, i, v);
}
t[id] = merge(t[x], t[y]);
}
int get(int id, int tl, int tr, int l, int r) {
if (r < tl || tr < l) return 1;
if (l <= tl && tr <= r) return t[id];
int x = (id << 1) + 1, y = x + 1, tm = (tl + tr) >> 1;
return merge(get(x, tl, tm, l, r), get(y, tm + 1, tr, l, r));
}
void update(int i, int v) { update(0, 0, n - 1, i, v); }
int get(int l, int r) { return get(0, 0, n - 1, l, r); }
};
// struct SegmentTree {
// int n;
// vector<i64> t;
// void init(int _n) {
// n = _n;
// t.assign(4 * n, 1);
// }
// void update(int id, int tl, int tr, int i, int v) {
// if (tl == tr) {
// t[id] = v;
// return;
// }
// int x = (id << 1) + 1, y = x + 1, tm = (tl + tr) >> 1;
// if (i <= tm) {
// update(x, tl, tm, i, v);
// } else {
// update(y, tm + 1, tr, i, v);
// }
// t[id] = t[x] * t[y] % mod;
// }
// int get(int id, int tl, int tr, int l, int r) {
// if (r < tl || tr < l) return 1;
// if (l <= tl && tr <= r) return t[id];
// int x = (id << 1) + 1, y = x + 1, tm = (tl + tr) >> 1;
// return get(x, tl, tm, l, r) * get(y, tm + 1, tr, l, r) % mod;
// }
// void update(int i, int v) { update(0, 0, n - 1, i, v); }
// int get(int l, int r) { return get(0, 0, n - 1, l, r); }
// };
struct FenwickTree {
int n;
vector<int> bit;
void init(int _n) {
n = _n;
bit.resize(n + 1);
}
void update(int k, int d) {
k++;
for (; k <= n; k += k & -k) {
bit[k] += d;
}
}
int get(int k) {
k++;
int ret = 0;
for (; k >= 1; k -= k & -k) {
ret += bit[k];
}
return ret;
}
int get(int l, int r) {
l++; r++;
return get(r) - get(l - 1);
}
};
int n;
SegmentTree t;
FenwickTree cnt;
vector<int> x, y;
bool is(int l, int r) {
i64 k = y[r];
for (int i = l + 1; i <= r; i++) {
k *= x[i];
if (k > y[l]) {
return true;
}
}
return false;
}
int solve() {
// int st = max(0, n - 1000);
int st = 0;
int pos = st;
i64 ans = t.get(0, pos) * y[pos] % mod;
i64 cur = 1;
for (int i = 0; i < n; i++) {
cur = cur * x[i] % mod;
assert(cur == t.get(0, i));
}
for (int i = st; i < n; i++) {
if (is(pos, i)) {
pos = i;
ans = t.get(0, i) * y[i] % mod;
}
}
return ans;
}
int init(int N, int X[], int Y[]) {
n = N;
x.assign(X, X + N);
y.assign(Y, Y + N);
t.init(n);
cnt.init(n);
for (int i = 0; i < n; i++) {
t.update(i, x[i]);
if (x[i] > 1) {
cnt.update(i, 1);
}
}
return solve();
}
int updateX(int pos, int val) {
if (x[pos] > 1) {
cnt.update(pos, -1);
}
if (val > 1) {
cnt.update(pos, 1);
}
t.update(pos, val);
x[pos] = val;
return solve();
}
int updateY(int pos, int val) {
y[pos] = val;
return solve();
}
