class SparseTableBase_:
    def ope(self, l, r):
        raise NotImplementedError

    def __init__(self, A):
        self.n = len(A)
        self.logn = (self.n - 1).bit_length()
        if self.n == 1:
            self.logn = 1
        self.table = [0] * (self.logn * self.n)
        for i in range(self.n):
            self.table[i] = A[i]
        for i in range(1, self.logn):
            ma = self.n - (1 << i) + 1
            d = 1 << (i - 1)
            for j in range(ma):
                self.table[i * self.n + j] = self.ope(
                    self.table[(i - 1) * self.n + j],
                    self.table[(i - 1) * self.n + j + d],
                )

        self.look = [0] * self.n
        for i in range(2, self.n):
            self.look[i] = self.look[i >> 1] + 1

    def prod(self, l, r):
        assert l < r
        d = r - l
        if d == 1:
            return self.table[l]
        logn = self.look[d - 1]
        return self.ope(
            self.table[logn * self.n + l], self.table[logn * self.n + r - (1 << logn)]
        )


class RangeMax(SparseTableBase_):
    def ope(self, l, r):
        return max(l, r)


n = int(input())
P = list(map(int, input().split()))
for i in range(n):
    P[i] -= 1
Q = int(input())

imos = [[0] * (2 * n) for _ in range(20)]
ans = [0] * n
st = RangeMax(P)

for _ in range(Q):
    l, r = map(int, input().split())
    l -= 1
    d = r - l
    rle = [(1, d)]
    k = d - 1
    p = 0
    minus = 0
    while k > 0:
        c = (rle[p][1] - minus) // 2
        minus = rle[p][1] - minus - 2 * c
        if c != 0:
            rle.append((rle[p][0] * 2, c))
        k -= c
        if minus == 1:
            k -= 1
            rle.append((rle[p][0] + rle[p + 1][0], 1))
        p += 1

    s = 0
    for c, t in rle[1:]:
        l_ = s
        r_ = s + c * t
        if r_ <= d:
            imos[c.bit_length() - 1][l + l_] += 1
            imos[c.bit_length() - 1][l + r_] -= 1
        else:
            ma1 = st.prod(l + l_, r)
            ma2 = st.prod(l, l + (r_ - d))
            ma = max(ma1, ma2)
            ans[ma] += 1

        s = r_ % d

for i in range(1, 20):
    d = 1 << i
    for j in range(d, n):
        imos[i][j] += imos[i][j - d]

    for j in range(n - d + 1):
        res = st.prod(j, j + d)
        ans[res] += imos[i][j]

print(*ans, sep="\n")