import java.io.*;
import java.util.*;
import java.util.Map.Entry;

public class BnPC {
	private static int points;
	private static HashMap<String, Integer> attributePoints = new HashMap<>();
	private static HashMap<String, HashMap<String, Integer>> attributeEventsInfo = new HashMap<>();


	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		int total = 0;

		String[] input = in.readLine().split(" ");
		points = Integer.parseInt(input[1]);
		for (int i = 0; i < Integer.parseInt(input[0]); i++) {
			String[] attribute = in.readLine().split(" ");
			attributePoints.put(attribute[0], Integer.parseInt(attribute[1]));
			HashMap<String, Integer> attributeEventInfo = new HashMap<>();
			attributeEventInfo.put("amount", 0);
			attributeEventInfo.put("highest", 0);
			attributeEventInfo.put("amountHighest", 0);
			attributeEventsInfo.put(attribute[0], attributeEventInfo);
		}

		int eventAmount = Integer.parseInt(in.readLine());
		for (int i = 0; i < eventAmount; i++) {
			String[] event = in.readLine().split(" ");
			HashMap<String, Integer> eventMap = attributeEventsInfo.get(event[0]);
			eventMap.put("amount", eventMap.get("amount") + 1);
			int threshold = Integer.parseInt(event[1]);
			if (threshold > attributeEventsInfo.get(event[0]).get("highest")) {
				eventMap.put("highest", threshold);
				eventMap.put("amountHighest", 1);
				if (threshold > attributePoints.get(event[0])) {
					points -= threshold - attributePoints.get(event[0]);
					attributePoints.put(event[0], threshold);
				}
			} else if (threshold == attributeEventsInfo.get(event[0]).get("highest")) {
				eventMap.put("amountHighest", eventMap.get("amountHighest") + 1);
			}
		}
//		for (int i = 0; i < points; i++) {
//			String bestAttr = "";
//			int bestImpact = 0;
//			for (String currentAttr : attributePoints.keySet()) {
//				int amount = attributeEventsInfo.get(currentAttr).get("amount");
//				int amountHighest = attributeEventsInfo.get(currentAttr).get("amountHighest");
//				int score = attributePoints.get(currentAttr) ;
//				if (attributePoints.get(currentAttr) == (attributeEventsInfo.get(currentAttr).get("highest"))) {
//					int impact = score * amountHighest + amount;
//					if (impact > bestImpact) {
//						bestAttr = currentAttr;
//						bestImpact = impact;
//					}
//				} else {
//					if (amount > bestImpact) {
//						bestAttr = currentAttr;
//						bestImpact = amount;
//					}
//				}
//			}
//			attributePoints.put(bestAttr, attributePoints.get(bestAttr) + 1);
//		}

		int mostOccurring = 0;
		String mostName = "";
		int events = attributeEventsInfo.size();
		ArrayList<String> totalsNames = new ArrayList<>();
		ArrayList<Integer> totalImpacts = new ArrayList<>();
		for (Entry<String, HashMap<String, Integer>> entry : attributeEventsInfo.entrySet()) {
			int amount = entry.getValue().get("amount");
			int amountHighest = entry.getValue().get("amountHighest");
			int score = attributePoints.get(entry.getKey());
			int impact = score * amountHighest + amount;
			totalsNames.add(entry.getKey());
			totalImpacts.add(impact);
			if (amount > mostOccurring) {
				mostOccurring = amount;
				mostName = entry.getKey();
			}
		}

		List[] sorted = sortTotals(new List[]{totalsNames, totalImpacts});
		totalsNames = (ArrayList<String>) sorted[0];
		totalImpacts = (ArrayList<Integer>) sorted[1];

		for (int i = 0; i < totalImpacts.size(); i++) {
			if (points <= 0) break;
			if (mostOccurring < totalImpacts.get(i)) {
				attributePoints.put(totalsNames.get(i), attributePoints.get(totalsNames.get(i)) + 1);
				points--;
			} else {
				attributePoints.put(mostName, attributePoints.get(mostName) + points);
				points = 0;
			}
		}

		attributePoints.put(mostName, attributePoints.get(mostName) + points);

		System.out.println(totalPoints());
	}

	private static int totalPoints() {
		int total = 0;
		for (Entry<String, Integer> entry : attributePoints.entrySet()) {
			HashMap<String, Integer> currentAttribute = attributeEventsInfo.get(entry.getKey());
			int attributeScore = entry.getValue();
			if (attributeScore == currentAttribute.get("highest")) {
				total += (currentAttribute.get("amount") - currentAttribute.get("amountHighest")) * attributeScore;
			} else if (attributeScore > currentAttribute.get("highest")) {
				total += currentAttribute.get("amount") * attributeScore;
			}
		}

		return total;
	}

	private static List[] sortTotals(List[] in) {
		ArrayList<Integer> list = new ArrayList<Integer>(in[1]);
		ArrayList<String> names = new ArrayList<String>(in[0]);
		if (list.size() <= 1) return in;
		List[] firstHalf = sortTotals(new List[]{names.subList(0, list.size()/2), list.subList(0, list.size()/2)});
		List[] secondHalf = sortTotals(new List[]{names.subList(list.size()/2, list.size()), list.subList(list.size()/2, list.size())});
		ArrayList<Integer> result = new ArrayList<>();
		ArrayList<String> namesResult = new ArrayList<>();
		int i = 0, n = 0;
		while (i < firstHalf[1].size() && n < secondHalf[1].size()) {
			if ((Integer) firstHalf[1].get(i) > (Integer) secondHalf[1].get(i)) {
				result.add((Integer) firstHalf[1].get(i));
				namesResult.add((String) firstHalf[0].get(i));
				i++;
			} else {
				result.add((Integer) secondHalf[1].get(n));
				namesResult.add((String) secondHalf[0].get(n));
				n++;
			}
		}
		while (i < firstHalf[1].size()) {
			result.add((Integer) firstHalf[1].get(i));
			namesResult.add((String) firstHalf[0].get(i));
			i++;
		}
		while (n < secondHalf[1].size()) {
			result.add((Integer) secondHalf[1].get(n));
			namesResult.add((String) secondHalf[0].get(n));
			n++;
		}
		return new List[]{namesResult, result};
	}
}