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);
        }
        
        @Override public boolean equals(Object o) {
            return o instanceof Sample && ((Sample)o).compareTo(this) == 0;
        }
    }
    
    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
            
            SortedSet<Sample> ss = new TreeSet<>();
            Queue<Sample> q = new ArrayDeque<>();
            if (r.ag == AG.avg) {
                long sum = 0;
                for (int i = 0; i < samples.size(); ++i) {
                    Sample si = samples.get(i);
                    
                    // odstran zacatek fronty mimo okno vzhledem k sample[i]
                    Sample rem;
                    while ((rem = q.peek()) != null && !rem.isInTimeInterval(si, r.L)) {
                        sum -= q.remove().v; // update souctu fronty
                    }
                    
                    // zapis okno do [i]
                    ev[i] = sum; // soucet vsech hodnot ve fronte
                    ws[i] = q.size(); // velikost fronty
                    
                    q.add(si); // pridej sample[i] do fronty
                    sum += si.v; // update souctu fronty
                }
                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]/ws[i]) {
                            satisfied++;
                        } else if (r.op == OP.gt && si.v > ev[i]/ws[i]) {
                            satisfied++;
                        }
                    }
                }
            } else if (r.ag == AG.min) {
                for (int i = 0; i < samples.size(); ++i) {
                    Sample si = samples.get(i);
                    
                    // odstran zacatek fronty mimo okno vzhledem k sample[i]
                    Sample rem;
                    while ((rem = q.peek()) != null && !rem.isInTimeInterval(si, r.L)) {
                        ss.remove(q.remove());
                    }
                    
                    ws[i] = q.size(); // velikost fronty
                    ev[i] = ss.isEmpty() ? 0 : ss.first().v; // min vsech hodnot ve fronte
                    
                    q.add(si); // pridej sample[i] do fronty
                    ss.add(si);
                }
                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 = 0; i < samples.size(); ++i) {
                    Sample si = samples.get(i);
                    
                    // odstran zacatek fronty mimo okno vzhledem k sample[i]
                    Sample rem;
                    while ((rem = q.peek()) != null && !rem.isInTimeInterval(si, r.L)) {
                        ss.remove(q.remove());
                    }
                    
                    ws[i] = q.size(); // velikost fronty
                    ev[i] = ss.isEmpty() ? 0 : ss.last().v; // max vsech hodnot ve fronte
                    
                    q.add(si); // pridej sample[i] do fronty
                    ss.add(si);
                }
                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);
        }
    }
}