#include <bits/stdc++.h>
#define rep(i, f, t) for(int i(f); i <= t; ++i)
#define re(i, t) for(int i(1); i <= t; ++i)
#define per(i, t, f) for(int i(t); i >= f; --i)
#define pe(i, t) for(int i(t); i >= 1; --i)
#define ste(i, f, t, s) for(int i(f); i <= t; i += s)
#define ets(i, t, f, s) for(int i(t); i >= f; i -= s)
#define each(i, x) for(auto &i : (x))
#define nx(i, u) for(int i(head[u]); i; i = e[i].nxt) 
typedef long long ll;
typedef long double lb;
typedef unsigned long long ull;
// #define int long long
using namespace std;
// typedef pair <double, int> pdi;
typedef pair <int, int> pii;
// typedef pair <string, bool> psb;
#define pb push_back
#define fi first
#define se second 
#define ix(l, r) ((l + r) | (l != r))
#define ls (ix(l, mid))
#define rs (ix(mid + 1, r))
#define mp(i, j) (make_pair(i, j))
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define i128 __int128
#define exp 1e-7
#define look_memory cerr<<abs(&sT-&eD)/1024.0/1024<<'\n'
int sT;    
 
struct IO {
    #define MAXSIZE 1<<21
    #define isdigit(x) (x >= '0' && x <= '9')
    #define isspace(x) (x == ' ' || x == '\n' || x == '\r' || x == '\t')
    char ibuf[MAXSIZE], obuf[MAXSIZE], *s1, *s2, *s3, endl, blank;
    int round[10] = {0, 0, 0, 0, 0, 1, 1, 1, 1}, sta[65], precisions;
    bool fail;
    FILE *in_stream, *out_stream;
    IO(FILE *_stream = stdin, FILE *__stream = stdout) { reset(_stream,__stream); }
    #if DEBUG
    #else
        ~IO() {close();}
    #endif
    inline void reset (FILE *_stream = stdin, FILE *__stream = stdout, bool reset = true) {
        s1 = s3 = ibuf, s2 = obuf, in_stream = _stream, out_stream = __stream, fail = false;
        if(reset) { endl = '\n'; blank = ' '; precisions = 6; }
    }
    inline void flush_in() {s3 = (s1 = ibuf) + fread(ibuf, 1, MAXSIZE, in_stream); }
    inline void flush_out() { fwrite(obuf, 1, s2-obuf, out_stream), s2 = obuf; }
    inline void flush_out_with_stream() { flush_out(); fflush(out_stream); } 
    inline char get() {
        #if DEBUG  
            return getchar();
        #endif
        return s1 == s3 && (flush_in(), fail = s1 == s3) ? 0 : *s1++;
    }
    inline void put(char ch) {
        #if DEBUG
            putchar(ch);
        #else
            s2-obuf == MAXSIZE ? flush_out(), 0 : 0, *s2++=ch;
        #endif
    }
    template <class T>
    inline void read(T &x) {
        bool sign = false; char c = get(); x = 0;
        while(!isdigit(c) && c) {sign=c=='-'; c = get(); }
        while(isdigit(c)) { x = (x<<1) + (x<<3) + (c^'0'); c = get(); }
        sign ? x = ~x+1 : 0;
    }
    inline void read(double &x) {
        bool sign = false; char c = get(); x = 0;
        while(!isdigit(c) && c) { sign=c=='-'; c = get(); }
        while(isdigit(c)) { x = x * 10 + (c^'0'); c = get(); }
        if(c=='.') { c = get(); double tmp = 1; while(isdigit(c)) { tmp /= 10, x += tmp * (c^'0'); c = get(); } }
        sign ? x = -x : 0;
    }
    inline void read(long double &x) {
        bool sign = false; register char c = get(); x = 0;
        while(!isdigit(c) && c) { sign=c=='-'; c = get(); }
        while(isdigit(c)) { x = x * 10 + (c^'0'); c = get(); }
        if(c == '.') { c = get(); register long double tmp = 1; while(isdigit(c)) { tmp /= 10, x += tmp * (c^'0'); c = get(); } }
        sign ? x = -x : 0;
    }
    inline void read(char *s) {
        char c = get();
        while(isspace(c)) c = get();
        while(!isspace(c) && c) { *s++=c; c = get(); }
        *s = '\0';
    }
    inline void read(char &c) {
        do
            c = get();
        while(isspace(c));
    }
    template <class T, class ...Args>
    inline void read(T &x, Args &...args) { read(x), read(args...); }
    template <class T>
    inline void write(T x) {
        int top = 0;
        if(x<0) { put('-'); sta[top++] = ~(x%10)+1, x /= 10; x = ~x+1; }
        else sta[top++] = x%10, x /= 10;
        while(x) sta[top++] = x%10 ,x /= 10;
        while(top) put(sta[--top]^'0');
    }
    inline void write(double y) {
        int top = 0;
        if(y<0) { put('-'); y=-y; }
        int x = y; y -=x;
        write(x);
        if(y) {
            do
                sta[top++] = y*10, y = y*10 - sta[top-1];
            while(top<precisions-1);
            sta[top++] = y*10 + round[(int)((y*10-((int)(y*10)))*10)];
        }
        put('.');
        for(int i(0); i<top; ++i) put(sta[i]^'0');
        for(int i(top); i<precisions; ++i) put('0');
    }
    inline void write(long double y) {
        register int top = 0;
        if(y<0) { put('-'); y=-y; }
        int x = y; y -= x;
        write(x);
        if(y) {
            do
                sta[top++] = y*10, y = y*10 - sta[top-1];
            while(top<precisions-1);
            sta[top++] = y*10 + round[(int)((y*10-((int)(y*10)))*10)];
        }
        put('.');
        for(register int i(0); i < top; ++i) put(sta[i]^'0');
        for(register int i(top); i < precisions; ++i) put('0');
    }
    inline void write(const char ch) { put(ch); }
    inline void write(char *s) { while(*s!='\0') put(*s++); }
    inline void write(const char *s) { while(*s!='\0') put(*s++); }
    inline void write(const std::string str) { write(str.c_str()); }
    inline IO &precision(const int x) { precisions=x; return *this; }
    template <class T,class ...Args>
    inline void write(T x,Args ...args) { write(x), blank?put(blank), 0:0, write(args...); }
    template <class ...Args>
    inline void writeln(Args ...args) { write(args...), endl?put(endl), 0:0; }
    template <class T>
    inline IO &operator>>(T &x) { read(x); return *this; }
    inline IO &operator>>(IO &x) { return *this; }
    template <class T>
    inline IO &operator<<(const T x) { write(x); return *this; }
    inline IO &operator<<(IO &x) { return *this; }
    inline operator bool() { return !fail; }
    template <class T>
    inline operator T() { T x; read(x); return x; }
    inline void open(FILE *_stream=stdin,FILE *__stream=stdout) { close(), reset(_stream, __stream, false); }
    inline void close() { flush_out_with_stream(); fclose(in_stream), fclose(out_stream); }
    #define read(x) io>>x
    #define out(x) io<<x
}io;
const int N = 1e5 + 5;
int n, a[N];
int m;
struct Que {
    int id, l, r;
}p[N];

bool cmp (Que a, Que b) {
    return a.r < b.r; 
}

int f[N];
ll ans[N][2], pre[N], tag[N][2], val[N][2];
int sq, bl[N], lth[N], rth[N];

void check (ll a, ll b, ll &x, ll &y) {
    if(!y) {
        x = a, y = b;
        return ;
    }
    if((i128)1 * a * y >= (i128)1 * b * x) {
        x = a, y = b;
    }
}

void update (int p, ll a, ll b) { 
    check(a, b, tag[bl[p]][0], tag[bl[p]][1]);
    check(a, b, val[p][0], val[p][1]);
}

void query (int id, int l, int r) {
    if(bl[l] + 1 >= bl[r]) {
        rep(i, l, r) {
            check(val[i][0], val[i][1], ans[id][0], ans[id][1]);
        }
        return ;
    }
    rep(i, l, rth[bl[l]]) {
        check(val[i][0], val[i][1], ans[id][0], ans[id][1]);
    }
    rep(i, lth[bl[r]], r) {
        check(val[i][0], val[i][1], ans[id][0], ans[id][1]);
    }
    rep(i, bl[l] + 1, bl[r] - 1) {
        check(tag[i][0], tag[i][1], ans[id][0], ans[id][1]);
    }
}

int main () {
    io >> n;
    sq = sqrt(n / 2 + 1);
    re(i, n) bl[i] = (i - 1) / sq + 1;
    re(i, bl[n]) {
        lth[i] = rth[i-1] + 1;
        rth[i] = i * sq;
    }
    rth[bl[n]] = n;
    re(i, n) io >> a[i];
    re(r, n) { 
        pre[r] = pre[r-1] + a[r];
        f[r] = r;
        int sum = 0;
        if(a[r] == 0) continue;
        if(a[r] < 0) {
            pe(l, r) {
                sum += a[l];
                if(sum >= 0) break;
                f[r] = l;
            } 
        }
        else {
            pe(l, r) {
                sum += a[l];
                if(sum <= 0) break;
                f[r] = l;
            }
        }
    }
    io >> m;
    re(i, m) {
        io >> p[i].l >> p[i].r;
        p[i].id = i;
    }
    sort(p + 1, p + m + 1, cmp);
    int now = 1;
    re(i, n) {
        per(j, i, f[i]) {
            update(j, 1ll * (pre[i] - pre[j-1]) * (pre[i] - pre[j-1]), i - j + 1);
        }
        while(now <= m && p[now].r <= i) {
            query(p[now].id, p[now].l, p[now].r);
            ++now;
        }
    }    
    re(i, m) {
        ll w = __gcd(ans[i][0], ans[i][1]);
        ans[i][0] /= w;
        ans[i][1] /= w;
        io << ans[i][0] << " " << ans[i][1] << "\n";
    }
    return 0;
}