#include <bits/stdc++.h>
using namespace std;

int n,q,ans;
char s[100010];

int rt,root[100010];

struct Persistent
{
    int tot,tl,tr,tv;
    int lo[4000010],ro[4000010],sumo[4000010];

    int newNode()
    {
        tot++;
        lo[tot] = ro[tot] = sumo[tot] = 0;
        return tot;
    }
    
    void init() { tot = 0;}

    int _add(int id,int last,int l,int r)
    {
        int mid = (l+r)>>1;
        lo[id] = lo[last]; ro[id] = ro[last];
        if(l == r) sumo[id] = sumo[last] + tv;
        else
        {
            if(tl <= mid) _add(lo[id]=newNode(),lo[last],l,mid);
            else _add(ro[id]=newNode(),ro[last],mid+1,r);
            sumo[id] = sumo[lo[id]] + sumo[ro[id]];
        }
        return id;
    }

    int _query(int id,int l,int r)
    {
        int mid = (l+r)>>1;
        if(tl <= l && r <= tr) return sumo[id];
        return (tl<=mid?_query(lo[id],l,mid):0) + (tr>mid?_query(ro[id],mid+1,r):0);
    }
    
    int add(int _tl,int _tv,int _last)
    {
        tl = tr = _tl; tv = _tv;
        return _add(newNode(),_last,1,n);
    }
    
    int query(int _root,int _tl,int _tr)
    {
        tl = _tl; tr = _tr;
        return _query(_root,1,n);
    }

}segTree;

struct Trie
{
    int tot,v[100010];
    unordered_map<char,int> ch[100010];
    
    int newNode()
    {
        tot++;
        v[tot] = 0; ch[tot].clear();
        return tot;
    }
    
    void init() { tot = 0; newNode();}
    
    void change(int val)
    {
        int i,now = 1;
        for(i=1;s[i];i++)
        {
            if(ch[now].find(s[i]) == ch[now].end())
                ch[now][s[i]] = newNode();
            now = ch[now][s[i]];
            
            if(v[now]) rt = segTree.add(v[now],-1,rt);
            rt = segTree.add(v[now]=val,1,rt);
        }
    }
}trie;

int main()
{
    int i,l,r;
    
    while(scanf("%d",&n) > 0)
    {
        ans = rt = 0;
        trie.init(); segTree.init();
        
        for(i=1;i<=n;i++)
        {
            scanf("%s",s+1);
            trie.change(i);
            root[i] = rt;
        }
        
        scanf("%d",&q);
        while(q--)
        {
            scanf("%d%d",&l,&r);
            l = (l+ans)%n+1; r = (r+ans)%n+1;
            if(l>r) swap(l,r);
            ans = segTree.sumo[root[r]] - (l>1?segTree.query(root[r],1,l-1):0);
            printf("%d\n",ans);
        }
    }
    return 0;
}