#include <fstream>
#include <queue>
#include <vector>
#include <functional>

#define MAXPROCESSORS 100005
using namespace std;

ifstream f("fabrica.in");
ofstream g("fabrica.out");

struct HeapItem {
	int time;
	int execDuration;

	HeapItem() {
		time = execDuration = 0;
	}

	HeapItem(int gTime, int gExecDuration) {
		time = gTime;
		execDuration = gExecDuration;
	}

	bool operator <(const HeapItem &i) const {
		if (i.time == time) return i.execDuration < execDuration;
		return i.time < time;
	}

};

void readData(int *procA, int *procB, int &procACount, int &procBCount, int &cansCount) {
	//
	f >> cansCount >> procACount >> procBCount;
	for (int i = 0; i < procACount; i++) {
		f >> procA[i];
	}

	for (int i = 0; i < procBCount; i++) {
		f >> procB[i];
	}
}

int getMax(int m1, int m2) {
	//
	return m1 > m2 ? m1 : m2;
}

void computeMinimumTimes(int *procA, int procACount, int *procB, int procBCount, int cansCount, int &procAMinTime, int &procBMinTime) {
	//
	priority_queue<HeapItem> procAHeap, procBHeap;

	for (int i = 0; i < procACount; i++) {
		procAHeap.push(HeapItem(procA[i], procA[i]));
	}

	for (int i = 0; i < procBCount; i++) {
		procBHeap.push(HeapItem(procB[i], procB[i]));
	}

	procAMinTime = 0;
	procBMinTime = 0;

	for (int i = 0; i < cansCount; i++) {
		//
		HeapItem firstA = procAHeap.top();
		procAHeap.pop();

		int canProcessAFinishTime = firstA.time;
		firstA.time += firstA.execDuration;
		procAMinTime = getMax(procAMinTime, canProcessAFinishTime);

		HeapItem firstB = procBHeap.top();
		procBHeap.pop();

		int processorBMinAvailableTime = firstB.time - firstB.execDuration;
		int phaseBEntryTime = getMax(processorBMinAvailableTime, canProcessAFinishTime);

		firstB.time = phaseBEntryTime + 2 * firstB.execDuration;
		procBMinTime = getMax(procBMinTime, phaseBEntryTime + firstB.execDuration);

		procAHeap.push(firstA);
		procBHeap.push(firstB);
	}

}

int main() {
	//
	int procA[MAXPROCESSORS], procB[MAXPROCESSORS];
	int procACount, procBCount, cansCount, procAMinTime, procBMinTime;

	readData(procA, procB, procACount, procBCount, cansCount);
	computeMinimumTimes(procA, procACount, procB, procBCount, cansCount, procAMinTime, procBMinTime);

	g << procAMinTime << " " << procBMinTime;
	return 0;
}