#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3, "Ofast", "inline")
#include <bits/stdc++.h>
#define endl '\n'
#define x first
#define y second
#define ls u << 1
#define rs u << 1 | 1
//#define int long long
using namespace std;
const int N = 1e5 + 10, lim = 0x3f3f3f3f, mod = 1e9 + 7, M = 2e5 + 10;
using PII = pair<int, int>;
using LL = long long;
struct custom_hash {
  static uint64_t splitmix64(uint64_t x) {
    x += 0x9e3779b97f4a7c15;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
    return x ^ (x >> 31);
  }

  size_t operator()(uint64_t x) const {
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(x + FIXED_RANDOM);
  }
};
struct Node {
  int l, r;
  unordered_map<int, int, custom_hash> p;
} tr[N << 2];

int prime[M], cnt, mind[M];
int a[N], n;
bool st[M];

int qmi(int a, int b) {
  int res = 1;
  while (b) {
    if (b & 1) res = 1ll * res * a % mod;
    a = 1ll * a * a % mod;
    b >>= 1;
  }
  return res;
}

void seive(int n) {
  for (int i = 2; i <= n; i++) {
    if (!st[i]) {
      prime[cnt++] = i;
      mind[i] = i;
    }
    for (int j = 0; j < cnt && prime[j] <= n / i; j++) {
      st[prime[j] * i] = 1;
      mind[prime[j] * i] = prime[j];
      if (i % prime[j] == 0) break;
    }
  }
}

void pushup(Node &u, Node &l, Node &r) {
  set<int> S;
  for (auto &[x, y] : l.p) S.insert(x);
  for (auto &[x, y] : r.p) S.insert(x);
  for (const int &v : S) u.p[v] = max(l.p[v], r.p[v]);
}

void pushup(int u) { pushup(tr[u], tr[ls], tr[rs]); }

void build(int u, int l, int r) {
  tr[u] = {l, r};
  if (l == r) {
    int x = a[l];
    while (x > 1) {
      int t = mind[x];
      int cnt = 0;
      while (x % t == 0) {
        cnt++;
        x /= t;
      }
      tr[u].p[t] = cnt;
    }
    return;
  }
  int mid = l + r >> 1;
  build(ls, l, mid);
  build(rs, mid + 1, r);
  pushup(u);
}

Node query(int u, int l, int r) {
  if (tr[u].l >= l && tr[u].r <= r) return tr[u];
  int mid = tr[u].l + tr[u].r >> 1;
  if (r <= mid) return query(ls, l, r);
  if (l > mid) return query(rs, l, r);
  Node res, left = query(ls, l, r), right = query(rs, l, r);
  pushup(res, left, right);
  return res;
}

void solve() {
  seive(200000);
  cin >> n;
  for (int i = 1; i <= n; i++) cin >> a[i];
  build(1, 1, n);
  LL last = 0;
  int q;
  cin >> q;
  while (q--) {
    int l, r;
    cin >> l >> r;
    l = (l + last) % n + 1;
    r = (r + last) % n + 1;
    if (l > r) swap(l, r);
    Node res = query(1, l, r);
    last = 1;
    for (auto &[x, y] : res.p) {
      last = last * qmi(x, y) % mod;
    }
    cout << last << endl;
  }
}

int main() {
  ios::sync_with_stdio(false), cin.tie(0);
  int T = 1;
  // cin>>T;
  while (T--) solve();
  return 0;
}