#include <queue>
#include <map>
#include <iostream>
#include <ios>

int partition(int table_to_sort[], int u, int o)
{
	int val = table_to_sort[u];
	int i1 = u, i2 = o, val2;
	while(true)
	{
		while(table_to_sort[i2] > val)
		{
			i2--;
		}

		while(table_to_sort[i1] < val)
		{
			i1++;
		}

		if(i1 < i2)
		{
			val2 = table_to_sort[i1];
			table_to_sort[i1] = table_to_sort[i2];
			table_to_sort[i2] = val2;
			i1++;
			i2--;
		}
		else
		{
			return i2;
		}
	}
}
 
void sort_table(int table_to_sort[], int u, int o)
{
	int l;
	if(u < o)
	{  
		l = partition(table_to_sort,u,o);
		sort_table(table_to_sort, u, l);
		sort_table(table_to_sort, l+1, o);
	}
}

int main()
{
	std::ios::sync_with_stdio(false);
	int n = 0;
	int m = 0;
	int k = 0;
	int* collection = NULL;
	int current_collection_size = 0;
	int different_elements_count = 0;
	int collection_id_1 = 0;
	int collection_id_2 = 0;
	int prioretized_queue_elements_sum = 0;
	std::priority_queue<int> prioretized_queue;
	std::map<int, char> different_elements_map;

	std::cin >> n;
	std::cin >> m;
	std::cin >> k;

	int** collections = new int*[n];

	for(register int i1 = 0; i1 < n; i1++)
	{
		std::cin >> current_collection_size;
		collection = new int[current_collection_size+1];
		collection[0] = current_collection_size;

		for(register int i2 = 1; i2 <= current_collection_size; i2++)
		{
			std::cin >> collection[i2];
		}

		sort_table(collection, 1, current_collection_size);
		collections[i1] = collection;
	}


	for(register int i1 = 0; i1 < k; i1++)
	{
		std::cin >> collection_id_1;
		std::cin >> collection_id_2;

		if(prioretized_queue_elements_sum & 1 == 1)
		{
			collection = collections[collection_id_2];
		}
		else
		{
			collection = collections[collection_id_1];
		}

		current_collection_size = collection[0];

		for(register int i2 = 1; i2 <= current_collection_size; i2++)
		{
			if(prioretized_queue.size() == 0 || prioretized_queue.size() < m || collection[i2] < prioretized_queue.top())
			{
				prioretized_queue_elements_sum = prioretized_queue_elements_sum + collection[i2];
				prioretized_queue.push(collection[i2]);

				if(m < prioretized_queue.size())
				{
					prioretized_queue_elements_sum = prioretized_queue_elements_sum - prioretized_queue.top();
					prioretized_queue.pop();
				}
			}
			else
			{
				break;
			}
		}
	}

	while(prioretized_queue.size() > 0)
	{
		different_elements_map[prioretized_queue.top()] = '.';
		prioretized_queue.pop();
	}

	different_elements_count = different_elements_map.size();
	std::cout << prioretized_queue_elements_sum << " " << different_elements_count;

	return 0;
}