#include <iostream>
#include <vector>
#include <numeric>
#include <random>
#include <cassert>
#include <chrono>
#include <tuple>

using namespace std;

// Fenwick Tree (Range Update/Range Query) - Provided in the prompt
#define LSB(x)((x) & -(x))
#define PARENT(x)(x + LSB(x))


using namespace std;
 
FILE * fpbuf = stdin;
 
const int BUFSIZE = 6140;
 
int ibuf = 0, ibufsz = 0;
 
char buffer[BUFSIZE];
 
#define fillbuf() { ibufsz = fread(buffer, sizeof(char), BUFSIZE, fpbuf); ibuf = 0; }
 
inline int readint() {
    int no = 0;
    while (ibuf == ibufsz || buffer[ibuf] == '\n' || buffer[ibuf] == '\r' || buffer[ibuf] == ' ') {
        if (ibuf == ibufsz) {
            fillbuf();
            if (ibufsz == 0) break;
        } else ibuf++;
    }
    int sgn = 1;
    if (buffer[ibuf] == '-') {
        sgn *= -1;
        ++ibuf;
    }
 
    while (1) {
        if (ibuf == ibufsz) {
            fillbuf();
            if (ibufsz == 0) break;
        }
        char ch = buffer[ibuf++];
        if (ch == '\r' || ch == '\n' || ch == EOF || ch == ' ') break;
        no = (no << 3) + (no << 1) + ch - 48;
    }
    return no * sgn;
}
 
inline int readstr(char * d, bool spacebrk = true) {
    while (ibuf == ibufsz || buffer[ibuf] == '\n' || buffer[ibuf] == '\r' || buffer[ibuf] == ' ') {
        if (ibuf == ibufsz) {
            fillbuf();
            if (ibufsz == 0) return 0;
        } else ibuf++;
    }
    int i = 0;
    while (true) {
        if (ibuf == ibufsz) {
            fillbuf();
            if (ibufsz == 0) break;
        }
        char ch = buffer[ibuf++];
        if (ch == '\r' || ch == '\n' || ch == EOF || (spacebrk && ch == ' ')) break;
        d[i++] = ch;
    }
    d[i] = '\0';
    return i;
}
 
inline void fastwritestr(char * s) {
    while (*s) putchar(*s++);
}
 
char numbuf[20];
 
inline void fastwriteint(int no) {
    numbuf[0] = '0';
    int i = no == 0 ? 1 : 0;
    bool neg = no < 0;
    if (neg) no *= -1;
    while (no) {
        numbuf[i++] = no % 10 + 48;
        no /= 10;
    }
    if (neg) putchar('-');
    while (i > 0) putchar(numbuf[--i]);
}


const int MAXN = 50001;
const int LOGN = 16;

struct VALUE {
	int best_prefix;
	int best_suffix;
	int best;
	int sum;
};

VALUE point[MAXN];
VALUE tree[MAXN];
int n_fenwick;

VALUE combine_value(const VALUE & a, const VALUE & b) {
    int pref = max(a.best_prefix, a.sum + b.best_prefix);
    int suf = max(b.best_suffix, b.sum + a.best_suffix);
    int sum = a.sum + b.sum;

    int best= max(a.best, b.best);
    best= max(best, a.best_suffix + b.best_prefix);
    best= max(best, a.best_suffix + b.best_prefix);
    return { pref, suf, best, sum };
}

void combine(int nd) {
    if (nd > n_fenwick) return;
    VALUE accumu;
    bool empty=true;
    int k = LSB(nd);
    int ch = nd - k;

    while (k > 1) {
        k /= 2;
        ch |= k;
        accumu = empty ? tree[ch] : combine_value(accumu, tree[ch]);
        empty = false;
    }
    accumu = empty ? point[nd]:combine_value(accumu,point[nd]);
    tree[nd] = accumu;
}

VALUE range_query_fenwick(int l, int r) {
    static int nodes[LOGN];
    int nodecnt = 0;
    
    VALUE ans;
    bool empty = true;
    while (l <= r) {
        int nr = r - LSB(r);

        if (nr < l) {
            VALUE segment = nr == l - 1 ? tree[r] : point[r];
            
            if (nr == l - 1) {
                r = l - 1;
            } else {
                r--;
            }
            
            while (nodecnt) {
                int nd=nodes[--nodecnt];
                segment =  combine_value(segment, tree[nd]);
  
            }
            ans=empty ? segment : combine_value(segment,ans);
            empty=false;
        } else {
            nodes[nodecnt++] = r;
            r = nr;
        }
    }
    return ans;
}

int main() {
    
    int n;

    n=readint();
    n_fenwick = n;
    
    for (int i = 1; i <= n; ++i) {
        int v=readint();
        point[i] = { v, v, v, v };
    	combine(i);
    }
    int q=readint();
    
    while (q--) {
            int a, b;
            a=readint();
            b=readint();
            int res = range_query_fenwick(a, b).best;
            fastwriteint(res);
            putchar('\n');
    }
    return 0;
}

#include <iostream>
using namespace std;

#define LSB(x)((x) & -(x))
#define PARENT(x)(x + LSB(x))

const int LOGN = 20;
struct Node {
    int len, open, ans;
};

#define VALUE Node

string s;
Node tree[1000001];
Node point[1000001];
int n_fenwick;

Node combine_value(const Node & a, const Node & b) {
    int nw = a.ans + b.ans + min(a.open - a.ans, b.len - b.open - b.ans);
    return {a.len + b.len, a.open + b.open, nw};
};

void combine(int nd) {
    if (nd > n_fenwick) return;

    tree[nd]=point[nd];
    int sibling = nd - LSB(nd);
    int child = nd - 1;

    while (child>sibling) {
        tree[nd] = combine_value(tree[child], tree[nd]);
        child-=LSB(child);
    }
}

VALUE range_query_fenwick(int l, int r) {
    VALUE ans;
    bool empty = true;

    while (l <= r) {
        int nr = r - LSB(r);
const VALUE &segment = (nr < l - 1 ? point[r] : tree[r]);
ans = empty ? segment : combine_value(segment, ans);
            r = nr < l - 1 ? r-1 : nr;
        empty = false;
    }
    return ans;
}

int main() {
    int m;
    cin >> s >> m;
    int n = s.size();
    n_fenwick=n;
    for (int i = 1; i <= n; ++i) {
        char c = s[i-1];
        point[i] = { 1, c=='(', 0 };
    	combine(i);
    }
    while (m--) {
        int l, r;
        cin >> l >> r;
        cout << range_query_fenwick(l, r).ans * 2 << '\n';
    }
    return 0;
}