#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>

using namespace std;

const double YOLO = 0.00000000001;

struct sample
{
    int m_time;
    int m_value;
};

struct condition
{
    string m_operator;
    string m_function;
    int m_time;
};

sample * sampleArr;
condition * condArr;
int ** RQMin;
int ** RQMax;
int findSmallerOrEqualExponentOfTwo(int in);

int getMax(int from, int to)
{
    int rozdil=to-from;
    int k = findSmallerOrEqualExponentOfTwo(rozdil);
    int d=1;
    for(int i=0;i<k;i++)
    {
        d*=2;
    }

    return max(RQMax[from][k],RQMax[to-d][k]);
}

int getMin(int from, int to)
{
    int rozdil=to-from;
    int k = findSmallerOrEqualExponentOfTwo(rozdil);
    int d=1;
    for(int i=0;i<k;i++)
    {
        d*=2;
    }

    return min(RQMin[from][k],RQMin[to-d][k]);
}

int bin(int from,int to,int time)
{
    if(from==to)
    {
        return from;
    }
    int mid=from+(to-from)/2;
    if(sampleArr[mid].m_time==time)
    {
        return mid;
    }
    else if (sampleArr[mid].m_time>time)
    {
        return bin(from,mid,time);
    }
    else
    {
        return bin(mid+1,to,time);
    }
}

int findSmallerOrEqualExponentOfTwo(int in)
{
    int res=-1;
    int d=1;
    while(d<=in)
    {
        res++;
        d*=2;
    }
    return res;
}


int main()
{

       // cout<<findSmallerOrEqualExponentOfTwo(7)<<findSmallerOrEqualExponentOfTwo(8)<<findSmallerOrEqualExponentOfTwo(9)<<endl;
    int sampleCount;
    while(cin>>sampleCount)
    {
        sampleArr = new sample [sampleCount];
        for(int i=0;i<sampleCount;i++)
        {
            cin>>sampleArr[i].m_time>>sampleArr[i].m_value;
        }
        int conditionCount;
        cin>>conditionCount;

        condArr = new condition[conditionCount];
        string flush;
        getline(cin,flush);
        for(int i=0;i<conditionCount;i++)
        {
            string con;
            getline(cin,con);
            condArr[i].m_operator=con.substr(0,2);
            condArr[i].m_function=con.substr(3,3);
            string tmp=con.substr(7);
            condArr[i].m_time=stoi(tmp);
        }

        long long * partSum = new long long [sampleCount];
        partSum[0]=sampleArr[0].m_value;
        for(int i=1;i<sampleCount;i++)
        {
            partSum[i]=partSum[i-1]+sampleArr[i].m_value;
        }

        int RQsize= findSmallerOrEqualExponentOfTwo(sampleCount);
        RQMin= new int * [sampleCount];
        RQMax= new int * [sampleCount];
        for(int i=0;i<sampleCount;i++)
        {
            RQMin[i]=new int[RQsize];
            RQMax[i]=new int[RQsize];
            RQMin[i][0]=sampleArr[i].m_value;
            RQMax[i][0]=sampleArr[i].m_value;
        }
        int d=1;
        for(int i=1;i<RQsize;i++)
        {

            for(int j=0;j<sampleCount;j++)
            {
                //int secI=j+d;
                if(j+d>=sampleCount)
                {
                    RQMin[j][i]=-1;
                    RQMax[j][i]=-1;
                }
                else
                {
                    RQMin[j][i]=min(RQMin[j][i-1],RQMin[j+d][i-1]);
                    RQMax[j][i]=max(RQMax[j][i-1],RQMax[j+d][i-1]);
                }
            }
            d*=2;
        }

        int * startIndexArr = new int [sampleCount];

       /* for(int i=0;i<sampleCount;i++)
        {
            for(int j=0;j<RQsize;j++)
            {
                cout<<RQMin[i][j]<<" ";
            }
            cout<<endl;
        }*/

        //QUERRY
        for(int c=0;c<conditionCount;c++)
        {
            int result=0;
            for(int i=0;i<sampleCount;i++)
            {
                double value;
                startIndexArr[i]=bin(0,i,sampleArr[i].m_time-condArr[c].m_time);
                if(startIndexArr[i]==i || i==0 )
                {
                    continue;
                }
                if(condArr[c].m_function=="max")
                {
                    value=getMax(startIndexArr[i],i);
                }
                if(condArr[c].m_function=="min")
                {
                    value=getMin(startIndexArr[i],i);
                }
                if(condArr[c].m_function=="avg")
                {
                    if(startIndexArr[i]==0)
                    {
                        value=(partSum[i-1])/(double)(i-startIndexArr[i]);
                    }
                    else
                    {
                        value=(partSum[i-1]-partSum[startIndexArr[i]-1])/(double)(i-startIndexArr[i]);
                    }

                }
                if(condArr[c].m_operator=="gt")
                {
                    if(sampleArr[i].m_value>value+YOLO)
                    {
                        result++;
                    }
                }
                if(condArr[c].m_operator=="lt")
                {
                    if(sampleArr[i].m_value<value-YOLO)
                    {
                        result++;
                    }
                }
               // cout<<c<<" ,i= "<<i<<" ="<<startIndexArr[i]<<" Value:"<<value<<endl;
            }
            cout<<result<<endl;

        }

    }


    return 0;
}