#pragma GCC optimize("Ofast")
#include "horses.h"
#include "bits/stdc++.h"

using ll = long long;
using i128 = __int128;
using namespace std;

struct mint {
	static constexpr int mod = 1e9 + 7;

	int data = 0;

	mint() = default;
	mint(int data) : data(data) {}

	mint operator+(const mint &other) const {
		int res = data + other.data;
		if (res >= mod) {
			res -= mod;
		}
		return res;
	}

	mint operator-(const mint &other) const {
		int res = data + mod - other.data;
		if (res >= mod) {
			res -= mod;
		}
		return res;
	}

	mint operator*(const mint &other) const {
		return mint(1ll * data * other.data % mod);
	}
};

int n;

constexpr int maxn = 1 << 19; 

int X[maxn];
int Y[maxn];

namespace st0 {
	int tree[maxn * 2 - 1];

	void set(int i) {
		int x = maxn + i - 1;
		tree[x] = i;

		while (x) {
			x = (x - 1) / 2;
			if (Y[tree[x * 2 + 1]] > Y[tree[x * 2 + 2]]) {
				tree[x] = tree[x * 2 + 1];
			} else {
				tree[x] = tree[x * 2 + 2];
			}
		}
	}

	int get(int l, int r, int x = 0, int lx = 0, int rx = maxn) {
		if (l <= lx && rx <= r) {
			return tree[x];
		}

		if (l >= rx || lx >= r) {
			return l;
		}

		int mx = (lx + rx) / 2;

		int i = get(l, r, x * 2 + 1, lx, mx);
		int j = get(l, r, x * 2 + 2, mx, rx);

		if (Y[i] > Y[j]) {
			return i;
		} else {
			return j;
		}
	}
} // namespace st0

namespace st2 {
	mint tree[maxn * 2 - 1];

	void set(int i, int v) {
		int x = maxn + i - 1;
		tree[x] = v;

		while (x) {
			x = (x - 1) / 2;
			tree[x] = tree[x * 2 + 1] * tree[x * 2 + 2];
		}
	}

	mint get(int l, int r, int x = 0, int lx = 0, int rx = maxn) {
		if (l <= lx && rx <= r) {
			return tree[x];
		}

		if (l >= rx || lx >= r) {
			return 1;
		}

		return get(l, r, x * 2 + 1, lx, (lx + rx) / 2) * get(l, r, x * 2 + 2, (lx + rx) / 2, rx);
	}
} // namespace st2

constexpr i128 INF = 1ll * mint::mod * mint::mod;

set<pair<int, int>> Q;

int calc() {
	vector<pair<int, int>> q;

	{
		i128 cur = 1;

		for (auto it = prev(Q.end()); ; it--) {
			int r = it->first;

			cur *= X[r];

			if (cur > INF) {
				break;
			} else {
				q.emplace_back(*it);
			}

			if (it == Q.begin()) {
				break;
			}
		}
	}

	reverse(q.begin(), q.end());

	vector<pair<i128, int>> v;
	for (i128 cur = 1; auto [a, b] : q) {
		cur *= X[a];
		v.emplace_back(cur * Y[b], b);
	}

	int pos = max_element(v.begin(), v.end())->second;

	return (st2::get(0, pos + 1) * Y[pos]).data;
}

int updateX(int pos, int val) {	
	if (X[pos] == val) {
		return calc();
	}

	if (X[pos] == 1 && pos != 0) {
		auto it = prev(Q.lower_bound(make_pair(pos, 0)));

		int r = (next(it) == Q.end() ? n : next(it)->first);
		
		int l1 = pos;
		int l2 = it->first;

		Q.erase(it);

		Q.emplace(l1, st0::get(l1, r));
		Q.emplace(l2, st0::get(l2, l1));
	} else if (val == 1 && pos != 0) {
		auto it = Q.lower_bound(make_pair(pos, 0));

		int i1 = it->second;
		int i2 = prev(it)->second;

		int i = (Y[i1] > Y[i2] ? i1 : i2);

		int l = prev(it)->first;

		Q.erase(prev(it));
		Q.erase(it);

		Q.emplace(l, i);
	}

	X[pos] = val;

	st2::set(pos, val);

	return calc();
}

int updateY(int pos, int val) {
	Y[pos] = val;
	
	st0::set(pos);

	auto it = Q.upper_bound(make_pair(pos, 0));

	int R = (it == Q.end() ? n : it->first);

	it = prev(it);

	Q.emplace(it->first, st0::get(it->first, R));
	Q.erase(it);

	return calc();
}

int init(int N, int _X[], int _Y[]) {
	n = N;

	Q.emplace(0, max_element(_Y, _Y + n) - _Y);

	for (int i = 0; i < n; i++) {
		X[i] = 1;
		Y[i] = _Y[i];
	}

	for (int i = 0; i < n; i++) {
		st0::set(i);
	}

	for (int i = 0; i < n; i++) {
		updateX(i, _X[i]);
	}

	for (int i = 0; i < n; i++) {
		st2::set(i, X[i]);
	}

	return calc();
}