import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Samples {

	private static int[] minIS;
	private static int[] maxIS;
	private static long[] sucIS;
	private static int[] times;

	/**
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException {
		BufferedReader reader = new BufferedReader(new InputStreamReader(
				System.in));
		String line;
		String l;
		String nums[];
		while ((line = reader.readLine()) != null) {
			int numLines = Integer.parseInt(line);
			times = new int[numLines];
			int[] values = new int[numLines];
			int vs = velkostStromu(numLines);
			minIS = new int[vs];
			Arrays.fill(minIS, Integer.MAX_VALUE);
			maxIS = new int[vs];
			Arrays.fill(maxIS, Integer.MIN_VALUE);
			sucIS = new long[vs];

			for (int i = 0; i < numLines; i++) {
				l = reader.readLine();
				nums = l.split(" ");
				times[i] = Integer.parseInt(nums[0]);
				int v = Integer.parseInt(nums[1]);
				values[i] = v;
				int ix = (vs / 2) + i;
				minIS[ix] = v;
				maxIS[ix] = v;
				sucIS[ix] = v;
			}

			vybudujStromy();

			l = reader.readLine();
			int p = Integer.parseInt(l);
			for (int i = 0; i < p; i++) {
				l = reader.readLine();
				int pocitadlo = 0;
				nums = l.split(" ");
				int timeBack = Integer.parseInt(nums[2]);
				if (nums[1].equals("min")) {
					for (int j = 1; j < values.length; j++) {
						int t = times[j] - timeBack;
						int indexZ = najdiIx(t, j);
						int minimum = najdiMin(0, (minIS.length / 2),
								minIS.length - 1, (minIS.length / 2) + indexZ,
								(minIS.length / 2) + j - 1);
						if (nums[0].equals("lt")) {
							if (values[j] < minimum) {
								pocitadlo++;
							}
						}
						if (nums[0].equals("gt")) {
							if (values[j] > minimum) {
								pocitadlo++;
							}
						}
					}
				} else if (nums[1].equals("max")) {
					for (int j = 1; j < values.length; j++) {
						int t = times[j] - timeBack;
						int indexZ = najdiIx(t, j);
						int maximum = najdiMax(0, (minIS.length / 2),
								minIS.length - 1, (minIS.length / 2) + indexZ,
								(minIS.length / 2) + j - 1);
						if (nums[0].equals("lt")) {
							if (values[j] < maximum) {
								pocitadlo++;
							}
						}
						if (nums[0].equals("gt")) {
							if (values[j] > maximum) {
								pocitadlo++;
							}
						}
					}
				} else {
					for (int j = 1; j < values.length; j++) {
						int t = times[j] - timeBack;
						int indexZ = najdiIx(t, j);
						long sucet = sucet(0, (minIS.length / 2),
								minIS.length - 1, (minIS.length / 2) + indexZ,
								(minIS.length / 2) + j - 1);
						double priemer = sucet / (double) (j - indexZ);
						if (nums[0].equals("lt")) {
							if (values[j] < priemer) {
								pocitadlo++;
							}
						}
						if (nums[0].equals("gt")) {
							if (values[j] > priemer) {
								pocitadlo++;
							}
						}
					}
				}
				System.out.println(pocitadlo);
			}
		}

	}

	private static int najdiMin(int koren, int treeLeft, int treeRight,
			int intervalLeft, int intervalRight) {
		if ((treeLeft == intervalLeft && treeRight == intervalRight)) {
			return minIS[koren];
		}
		if (intervalLeft == intervalRight) {
			return minIS[intervalLeft];
		}
		int sIx = (treeLeft + treeRight) / 2;
		if (intervalRight <= sIx) {
			return najdiMin(2 * koren + 1, treeLeft, sIx, intervalLeft,
					intervalRight);
		} else if (intervalLeft > sIx) {
			return najdiMin(2 * koren + 2, sIx + 1, treeRight, intervalLeft,
					intervalRight);
		}
		return Math.min(
				najdiMin(2 * koren + 1, treeLeft, sIx, intervalLeft, sIx),
				najdiMin(2 * koren + 2, sIx + 1, treeRight, sIx + 1,
						intervalRight));
	}

	private static long sucet(int koren, int treeLeft, int treeRight,
			int intervalLeft, int intervalRight) {
		if ((treeLeft == intervalLeft && treeRight == intervalRight)) {
			return sucIS[koren];
		}
		if (intervalLeft == intervalRight) {
			return sucIS[intervalLeft];
		}
		int sIx = (treeLeft + treeRight) / 2;
		if (intervalRight <= sIx) {
			return sucet(2 * koren + 1, treeLeft, sIx, intervalLeft,
					intervalRight);
		} else if (intervalLeft > sIx) {
			return sucet(2 * koren + 2, sIx + 1, treeRight, intervalLeft,
					intervalRight);
		}
		return sucet(2 * koren + 1, treeLeft, sIx, intervalLeft, sIx)
				+ sucet(2 * koren + 2, sIx + 1, treeRight, sIx + 1,
						intervalRight);
	}

	private static int najdiMax(int koren, int treeLeft, int treeRight,
			int intervalLeft, int intervalRight) {
		if ((treeLeft == intervalLeft && treeRight == intervalRight)) {
			return maxIS[koren];
		}
		if (intervalLeft == intervalRight) {
			return maxIS[intervalLeft];
		}
		int sIx = (treeLeft + treeRight) / 2;
		if (intervalRight <= sIx) {
			return najdiMax(2 * koren + 1, treeLeft, sIx, intervalLeft,
					intervalRight);
		} else if (intervalLeft > sIx) {
			return najdiMax(2 * koren + 2, sIx + 1, treeRight, intervalLeft,
					intervalRight);
		}
		return Math.max(
				najdiMax(2 * koren + 1, treeLeft, sIx, intervalLeft, sIx),
				najdiMax(2 * koren + 2, sIx + 1, treeRight, sIx + 1,
						intervalRight));
	}

	private static int najdiIx(int time, int ix) {
		int startIx = 0;
		int endIx = ix;

		while (startIx < endIx - 1) {
			int stred = (startIx + endIx) / 2;
			if (times[stred] < time) {
				startIx = stred + 1;
			} else {
				endIx = stred;
			}
		}

		if (times[startIx] < time) {
			return endIx;
		}
		return startIx;
	}

	private static void vybudujStromy() {
		int startIx = (minIS.length / 2) - 1;

		for (int i = startIx; i >= 0; i--) {
			minIS[i] = Math.min(minIS[(2 * i) + 1], minIS[(2 * i) + 2]);
			maxIS[i] = Math.max(maxIS[(2 * i) + 1], maxIS[(2 * i) + 2]);
			sucIS[i] = sucIS[(2 * i) + 1] + sucIS[(2 * i) + 2];
		}
	}

	private static int velkostStromu(int num) {
		int m = 1;
		while (m < num) {
			m *= 2;
		}
		m *= 2;
		return m - 1;
	}

}