#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#pragma GCC optimize("Ofast,unroll-loops")
using namespace std;
using namespace __gnu_pbds;
template<class T> using oset= tree<T , null_type , less<T> , rb_tree_tag , tree_order_statistics_node_update>;
int n , Q=18 , q;
struct block{
    int cnt;
    vector<int> mas;
    vector<int> smas;
};
vector<int> mas;
vector<vector<int> > t;
vector<block> blocks;
vector<vector<int> > m;
vector<vector<int> > pref_m;
vector<vector<int> > pref_stolb;
void build(int v , int l , int r){
    if(l==r){
        t[v].push_back(mas[l]);
    }
    else{
    int mid=(l+r)/2;
    build(v*2 , l , mid);
    build(v*2+1 , mid+1 , r);
    int l1=0;
    int l2=0;
    while(l1!=t[v*2].size()||l2!=t[v*2+1].size()){
        if(l1==t[v*2].size()){
        t[v].push_back(t[v*2+1][l2]);
        l2++;
        }
        else{
            if(l2==t[v*2+1].size()){
                t[v].push_back(t[v*2][l1]);
                l1++;
            }
            else{
                if(t[v*2][l1]<=t[v*2+1][l2]){
                    t[v].push_back(t[v*2][l1]);
                    l1++;
                }
                else{
                    t[v].push_back(t[v*2+1][l2]);
                    l2++;
                }
            }
        }
    }
    }
}
int dih_t(int v , int x){
    int siz=t[v].size();
    int l=0 , r=siz-1;
    int ans=0;
    //cout << l << "-" << r << " " << siz << endl;
    while(l<=r){
            int mid=(l+r)/2;
            if(t[v][mid]>x){
                ans=siz-mid;
                r=mid-1;
            }
            else{
                l=mid+1;
            }
    }
   // cout << ans << ";" << endl;
    return ans;
}
int find_ans(int v , int l , int r , int tl , int tr , int x){
   /*cout << v << endl;
  system("pause");*/
    if(tl==l&&tr==r){
        return dih_t(v , x);
    }
    else{
        int mid=(l+r)/2;
        if(tr<=mid){
            return find_ans(v*2 , l , mid , tl , tr , x);
        }
        if(tl>mid){
            return find_ans(v*2+1 , mid+1 , r , tl , tr , x);
        }
        return find_ans(v*2 , l , mid , tl , mid , x)+find_ans(v*2+1 , mid+1 , r , mid+1 , tr , x);
    }
}
int find_blocks(int a , int b){
    int ans=0;
    if(a==b){
        return blocks[a].cnt;
    }
    if(a<b){
        swap(a , b);
    }
    else{
        int l1=0 , l2=0;
        while(l1!=blocks[a].smas.size()&&l2!=blocks[b].smas.size()){
            if(blocks[a].smas[l1]>blocks[b].smas[l2]){
                ans+=blocks[a].smas.size()-l1;
                l2++;
            }
            else{
                l1++;
            }
        }
    }
    return ans;
}
int find_cnt(int a){
    if(blocks[a].mas.size()==0){
        return 0;
    }
    oset<int> s;
    int ans=0;
    for(int i=0;i<blocks[a].mas.size();i++){
        ans+=s.size()-s.order_of_key(blocks[a].mas[i]);
        s.insert(blocks[a].mas[i]);
    }
    return ans;
}
int pref_ans=0;
void solve(){
    int ans=0;
    int l , r;
    cin >> l >> r;
    l=((pref_ans+l-1)%n)+1;
    r=((pref_ans+r-1)%n)+1;
    l--;
    r--;
    if(l>r){
        swap(l , r);
    }
   // cout << l << " " << r << endl;
    int q_min=999999 , q_max=-1;
    for(int i=l;i<=r;){
        if(i%Q==0&&i+Q-1<=r){
        ans+=blocks[i/Q].cnt;
        q_min=min(q_min , i/Q);
        q_max=i/Q;
        i+=Q;
        }
        else{
            if(i!=l){
            ans+=find_ans(1 , 0 , n-1 , l , i-1 , mas[i]);
     //       cout << ans << endl;
            }
            //cout << "bebraa" << endl;
            i++;
        }
    }
    if(q_min!=999999){
            if(q_min==0){
                ans+=pref_m[q_max][q_max];
            }
            else{
        ans+=pref_m[q_max][q_max]-pref_m[q_max][q_min-1]-pref_m[q_min][q_max-1];
            }
    }
    cout << ans << endl;
    pref_ans=ans;
}
int main(){
    cin >> n;
    mas.resize(n+1);
    t.resize(4*(n+1)+1);
    pref_m.resize(n/Q+1 , vector<int>(n/Q+1));
    blocks.resize(n/Q+1);
    m.resize(n/Q+1 , vector<int>(n/Q+1));
    pref_stolb.resize(n/Q+1 , vector<int>(n/Q+1));
    for(int i=0;i<n;i++){
        cin >> mas[i];
    }
    build(1 , 0 , n-1);
  /*  for(int i=1;i<t.size();i++){
        if(t[i].size()!=0){
                cout << i << ": ";
            for(int j=0;j<t[i].size();j++){
                cout << t[i][j] << " ";
            }
            cout << endl;
        }
    }*/
    for(int i=0;i<n;i++){
        blocks[i/Q].mas.push_back(mas[i]);
    }
    for(int i=0;i<=n/Q;i++){
        if(blocks[i].mas.size()!=0){
        blocks[i].smas=blocks[i].mas;
        sort(blocks[i].smas.begin() , blocks[i].smas.end());
        }
    }
    for(int i=0;i<=n/Q;i++){
            if(blocks[i].mas.size()!=0){
        blocks[i].cnt=find_cnt(i);
            }
    }
    for(int i=0;i<=n/Q;i++){
        for(int j=0;j<=n/Q;j++){
            m[i][j]=find_blocks(i , j);
            if(i==0){
                pref_stolb[i][j]=m[i][j];
            }
            else{
                pref_stolb[i][j]=pref_stolb[i-1][j]+m[i][j];
            }
            if(j==0){
                pref_m[i][j]=pref_stolb[i][j];
            }
            else{
                pref_m[i][j]=pref_stolb[i][j]+pref_m[i][j-1];
            }
        }
    }
    cin >> q;
    while(q--){
        solve();
    }
    return 0;
}