import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;


/**
 *
 * @author cteam040
 */
public class Samples {
    private static class TestRecord {
        public TestRecord(int time, int val) {
            this.time = time;
            this.val = val;
        }
        
        public int time;
        public int val;
    }  
    
    private static interface Validator {
        boolean validate(int x, int y);
    }
    
    private static class GtValidator implements Validator {
        public boolean validate(int x, int y) {
            return x > y;
        }
    }
    
    private static class LtValidator implements Validator {
        public boolean validate(int x, int y) {
            return x < y;
        }
    }
    
    private interface Aggregator {
        void reset();
        void add(int x);
        int getResult();
    }
    
    private static class MaxAggregator implements Aggregator {
        private int val = 0;
        public void reset() {
            val = 0;
        }
        public void add(int x) {
            if (x > val) val = x;
        }
        public int getResult() {
            return val;
        }
    }
    
    private static class MinAggregator implements Aggregator {
        private int val = Integer.MAX_VALUE;
        public void reset() {
            val = Integer.MAX_VALUE;
        }
        public void add(int x) {
            if (x < val) val = x;
        }
        public int getResult() {
            return val;
        }
    }
    
    private static class Average implements Aggregator {
        private int val = 0;
        private int count = 0;
        public void reset() {
            val = 0;
            count = 0;
        }
        public void add(int x) {
            val += x;
            count++;
        }
        public int getResult() {
            return val / count;
        }
    }
    
    private static class ConditionList {
        private List<Condition> conditions = new ArrayList<Condition>();
        private int maxTime = 0;
        
        public void addCondition(Condition cond) {
            if (cond.duration > maxTime) maxTime = cond.duration;
            conditions.add(cond);
        }
        
        public void run(int n) {
            int i = n - 1;
            TestRecord item = data.get(n);
            for (Condition cond : conditions) {
                cond.aggregator.reset();
            }
            int count = 0;
            
            while ((i >= 0) && (item.time - data.get(i).time) <= maxTime) {
                for (Condition cond : conditions) {
                    if (item.time - data.get(i).time <= cond.duration) {
                        cond.aggregator.add(data.get(i).val);
                    }
                }
                i--;
                count++;
            }   
            
            if (count == 0) return;
            
            for (Condition cond : conditions) {
                if (cond.validator.validate(item.val, cond.aggregator.getResult())) {
                    cond.counter++;
                }
            }
        }
    }
        
    public static class Condition {
        public int duration;
        public Validator validator;
        public Aggregator aggregator;
        public int counter = 0;
        
        public Condition(int duration, Validator validator, Aggregator aggregator) {
            this.duration = duration;
            this.validator = validator;
            this.aggregator = aggregator;
        }
        
        public boolean isSatisfied(int n) {
            int i = n - 1;
            TestRecord item = data.get(n);
            aggregator.reset();
            int count = 0;
            while ((i >= 0) && (item.time - data.get(i).time) <= duration) {
                aggregator.add(data.get(i).val);
                i--;
                count++;
            }
            
            if (count == 0) return false;
            
            return validator.validate(item.val, aggregator.getResult());
        }
    }
    
    private static List<TestRecord> data;
    private static List<Condition> conds;
    
    private static void runTestCase(BufferedReader in, int n) throws IOException {
        data = new ArrayList<>();
        conds = new ArrayList<>();
        
        for(int i = 0; i < n; i++) {
            String[] parts = in.readLine().split(" ");
            
            data.add(new TestRecord(Integer.parseInt(parts[0]), Integer.parseInt(parts[1])));
        }
        
        int condCount = Integer.parseInt(in.readLine());
        
        for (int i = 0; i < condCount; i++) {
            String[] parts = in.readLine().split(" ");
            Validator validator = parts[0].equals("gt") ? new GtValidator() : new LtValidator();
            Aggregator aggregator = parts[1].equals("avg") ? new Average() : (parts[1].equals("max") ? new MaxAggregator() : new MinAggregator());
            conds.add(new Condition(Integer.parseInt(parts[2]), validator, aggregator));
        }
        
        /*
        for(int i = 0; i < n; i++) {
            for (Condition cond : conds) {
                if (cond.isSatisfied(i)) {
                    cond.counter++;
                }
            }
        }
                */
        
        ConditionList clist = new ConditionList();
        
        for (Condition cond : conds) {
            clist.addCondition(cond);
        }
        
        for(int i = 0; i < n; i++) {
            clist.run(i);
        }        
        
        for (Condition cond : conds) {
            System.out.println(cond.counter++);
        }
    }
    
    public static void main(String[] args) throws IOException {

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

        while (true) {
            String line = in.readLine();
            if (line == null) break;
            int nTest = Integer.parseInt(line);
            runTestCase(in, nTest);
        }
    }
}