#include <iostream>
#include <algorithm>
#include <stack>
#include <vector>
#include <chrono>
#include <random>

using namespace std;

mt19937 R(chrono::steady_clock::now().time_since_epoch().count());

int Rand (int l, int r) {
  return uniform_int_distribution<int>(l, r)(R);
} 

using LL = long long;

struct Frac {
  LL x, y; 

  Frac () : x(0), y(1) {}
  Frac (LL _x, LL _y) : x(_x), y(_y) {
    LL g = __gcd(x, y);
    x /= g, y /= g;
  }

  bool operator< (Frac a) const { return (__int128)x * a.y < (__int128)a.x * y; }
  void Print () { cout << x << ' ' << y << '\n'; } 
}; 

struct Node {
  int o, l, r, v;
};

const int N = 2e3 + 5; 

int n, m;
int a[N], s[N], Rles[N], Rgre[N], tr[N], ans[N][N];
vector<Frac> fvec;
vector<Node> arr;

void Init (int o, int *ret) {
  stack<int> st;
  fill(ret + 1, ret + n + 1, n + 1);
  for (int i = 1; i <= n; ++i) {
    while (!st.empty() && (!o ? s[i] < s[st.top()] : s[i] > s[st.top()])) {
      ret[st.top()] = i;
      st.pop();
    }
    st.push(i);
  }
}

void Insert (int x, int y) {
  for (; x <= n; x += (x & -x)) {
    tr[x] = max(tr[x], y);
  }
}

int Query (int x) {
  int res = 0; 
  for (; x; x -= (x & -x)) {
    res = max(res, tr[x]);
  }
  return res;
}

int main () {
  cin.tie(0)->sync_with_stdio(0);
  cin >> n;
  if (n > 2000) return 0;
  for (int i = 1; i <= n; ++i) {
    cin >> a[i];
    s[i] = s[i - 1] + a[i];
  }
  Init(0, Rles), Init(1, Rgre);
  vector<pair<pair<int, int>, Frac>> vec;
  Frac mx = Frac(0, 1);
  for (int i = 1; i <= n; ++i) {
    for (int j = i, k = i; j < Rles[i] || k < Rgre[i]; ) {
      auto Add = [&](int p) -> void {
        vec.push_back({{i, p}, Frac(1ll * (s[p] - s[i - 1]) * (s[p] - s[i - 1]), p - i + 1)});
        mx = max(mx, vec.back().second);
      };
      if (j == k) {
        Add(j), j = Rgre[j], k = Rles[k];
      }
      else if ((j < Rles[i]) && (k >= Rgre[i] || j < k)) {
        Add(j), j = Rgre[j];
      }
      else {
        Add(k), k = Rles[k];
      }
    }
  }
  if (n > int(1e5)) {
    mx.Print();
    return 0; 
  }
  sort(vec.begin(), vec.end(), [&](pair<pair<int, int>, Frac> a, pair<pair<int, int>, Frac> b) -> bool {
    return a.second < b.second;
  });
  fvec.resize(vec.size()), arr.resize(vec.size());
  for (int i = 0; i < vec.size(); ++i) {
    fvec[i] = vec[i].second; 
    arr[i] = Node({0, vec[i].first.first, vec[i].first.second, i}); 
    ans[arr[i].l][arr[i].r] = arr[i].v;
  }
  for (int l = 2; l <= n; ++l) {
    for (int i = 1, j = l; j <= n; ++i, ++j) {
      ans[i][j] = max(ans[i][j], max(ans[i][j - 1], ans[i + 1][j]));
    }
  }
  cin >> m;
  for (int i = 1, l, r; i <= m; ++i) {
    cin >> l >> r;
    fvec[ans[l][r]].Print();
  }
  return 0;
}