import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.List;
import java.util.ArrayList;
import java.util.Queue;
import java.util.SortedSet;
import java.util.TreeSet;
/**
 *
 * @author tym11
 */
public class samples {
    static class Sample implements Comparable<Sample> {
        final int t;
        final int v;
        Sample(int t, int v) {
            this.t = t;
            this.v = v;
        }
        @Override
        public String toString() {
            return "t=" + t + " v=" + v;
        }
        
        boolean isInTimeInterval(Sample fromSample, int L) {
            return t >= fromSample.t - L;
        }

        @Override
        public int compareTo(Sample o) {
            return Integer.compare(v, o.v);
        }
    }
    
    private enum OP {
        gt, lt;
    }
    
    private enum AG {
        min, max, avg;
    }
    
    static class Rule {
        final OP op;
        final AG ag;
        final int L;
        
        Rule(OP op, AG ag, int L) {
            this.op = op;
            this.ag = ag;
            this.L = L;
        }
        
        @Override
        public String toString() {
            return op.name() + " " + ag.name() + " " + L;
        }
    }
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        
        for(;;) {
            String s = in.readLine();
            if (s == null) 
                break;
            
            int n = Integer.valueOf(s);
            List<Sample> samples = new ArrayList<>(n);
            for (int i = 0; i < n; ++i) {
                String[] f = in.readLine().split(" ");
                samples.add(new Sample(Integer.valueOf(f[0]), Integer.valueOf(f[1])));
            }
            
            int nRules = Integer.valueOf(in.readLine());
            List<Rule> rules = new ArrayList<>(nRules);
            for (int i = 0; i < nRules; ++i) {
                String[] f = in.readLine().split(" ");
                rules.add(new Rule(OP.valueOf(f[0]), AG.valueOf(f[1]), Integer.valueOf(f[2])));
            }
            
            solve(samples, rules);
        }
    }

    private static void solve(List<Sample> samples, List<Rule> rules) {        
        for (Rule r: rules) {
            int satisfied = 0;
            long[] ev = new long[samples.size()]; // evaluated window for j < i
            int[] ws = new int[samples.size()]; // window size
            
            ev[0] = 0;
            ws[0] = 0;
            SortedSet<Sample> ss = new TreeSet<>();
            Queue<Sample> q = new ArrayDeque<>();
            if (r.ag == AG.avg) {
                for (int i = 1; i < samples.size(); ++i) {
                    ev[i] = updateSum(ev[i-1], q, samples.get(i-1), r);
                    ws[i] = q.size();
                }
                for (int i = 0; i < samples.size(); ++i) {
                    Sample si = samples.get(i);
                    if (ws[i] > 0) {
                        if (r.op == OP.lt && si.v * ws[i] < ev[i]) {
                            satisfied++;
                        } else if (r.op == OP.gt && si.v * ws[i] > ev[i]) {
                            satisfied++;
                        }
                    }
                }
            } else if (r.ag == AG.min) {
                for (int i = 1; i < samples.size(); ++i) {
                    ev[i] = updateMin(q, samples.get(i-1), r, ss);
                    ws[i] = q.size();
                }
                for (int i = 0; i < samples.size(); ++i) {
                    Sample si = samples.get(i);
                    if (ws[i] > 0) {
                        if (r.op == OP.lt && si.v < ev[i]) {
                            satisfied++;
                        } else if (r.op == OP.gt && si.v > ev[i]) {
                            satisfied++;
                        }
                    }
                }
            } else if (r.ag == AG.max) { 
                for (int i = 1; i < samples.size(); ++i) {
                    ev[i] = updateMax(q, samples.get(i-1), r, ss);
                    ws[i] = q.size();
                }
                for (int i = 0; i < samples.size(); ++i) {
                    Sample si = samples.get(i);
                    if (ws[i] > 0) {
                        if (r.op == OP.lt && si.v < ev[i]) {
                            satisfied++;
                        } else if (r.op == OP.gt && si.v > ev[i]) {
                            satisfied++;
                        }
                    }
                }
            }
            
            System.out.println(satisfied);
        }
    }
    
    private static long updateSum(long sum, Queue<Sample> samples, Sample ns, Rule r) {
        int L = r.L;
        
        Sample rem;
        while ((rem = samples.peek()) != null && !rem.isInTimeInterval(ns, L)) {
            sum -= samples.remove().v;
        }
        
        samples.add(ns);
        sum += ns.v;
        
        return sum;
    }
    
    private static long updateMin(Queue<Sample> samples, Sample ns, Rule r, SortedSet<Sample> ss) {
        int L = r.L;
        
        Sample rem;
        while ((rem = samples.peek()) != null && !rem.isInTimeInterval(ns, L)) {
            ss.remove(samples.remove());
        }
        
        samples.add(ns);
        ss.add(ns);
        
        return ss.isEmpty() ? 0 : ss.first().v;
    }
    
    private static long updateMax(Queue<Sample> samples, Sample ns, Rule r, SortedSet<Sample> ss) {
        int L = r.L;
        
        Sample rem;
        while ((rem = samples.peek()) != null && !rem.isInTimeInterval(ns, L)) {
            ss.remove(samples.remove());
        }
        
        samples.add(ns);
        ss.add(ns);
        
        return ss.isEmpty() ? 0 : ss.last().v;
    }
}