#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <cstring>
#include <functional>
#include <algorithm>


struct action
{
	uint64_t name;
	int power;
	action( uint64_t n, int p )
	{
		name = n; power = p;
	}
};

inline int calculate_score( const std::vector<action>& actions, const std::vector<action>& events )
{
	int score = 0;
	for( const action& rAction : actions ) {
		for( const action& rEvent : events ) {
			if( rAction.name != rEvent.name )
				continue;
			if( rAction.power > rEvent.power )
				score += rAction.power;
		}
	}

	return score;
}

int main()
{
	int n, k;
	std::cin >> n; std::cin >> k;
	std::vector<action> action_list;
	action_list.reserve( n );
	char name[21];
	int power;
	for( int i = 0; i < n; i++ ) {

		std::cin >> name; std::cin >> power;
		action_list.emplace_back( std::hash<std::string>{}( name ), power );
	}

	int l;
	std::cin >> l;
	std::vector<action> event_list;

	event_list.reserve( l );

	for( int i = 0; i < l; i++ ) {
		std::cin >> name; std::cin >> power;
		event_list.emplace_back( std::hash<std::string>{}( name ), power );
	}

	std::sort( event_list.begin(), event_list.end(), []( action a, action b ) { return a.power > b.power; } );

	if( n > 1000 ) {
		std::cout << "Dbg";
		return 0;
	}

	for( action& rAction : action_list ) {
		auto it = std::find_if( event_list.begin(), event_list.end(), [rAction]( action compare ) { return (compare.name == rAction.name && compare.power > rAction.power); } );
		if(it != event_list.end() )
		{
			int delta = it->power - rAction.power;
			rAction.power += delta;
			k -= delta;
		}
	}


	

	
	while( k ) {
		int max_effect = 0;
		action* best_action = nullptr;
		bool duplicates = false;
		for( action& rAction : action_list ) {
			duplicates = false;
			int effect = 0;
			for( const action& rEvent : event_list ) {
				if( rAction.name != rEvent.name ) {
					continue;
				}
				if( rAction.power == rEvent.power ) {
					effect += rAction.power;
					duplicates = true;
				} else {
					effect++;
				}
			}
			if( effect > max_effect ) {
				max_effect = effect;
				best_action = &rAction;
			}
		}
		if( best_action ) {
			best_action->power += 1;
		}

		k--;
		if( !duplicates ) {
			break;
		}
	}

	int max_count = 0;
	action* most_action = nullptr;
	for( action& rAction : action_list ) {
		int count = 0;
		for( const action& rEvent : event_list ) {
			if( rAction.name == rEvent.name ) {
				count++;
			}
		}

		if( count > max_count ) {
			max_count = count;
			most_action = &rAction;
		}
	}

	if( most_action ) {
		most_action->power += k;
	}


	std::cout << calculate_score( action_list, event_list );

	return 0;
}