#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;
	int prevProcAFinishTime = 0;

	for (int i = 0; i < cansCount; i++) {
		//
		HeapItem firstA = procAHeap.top();
		procAHeap.pop();
		if (prevProcAFinishTime > firstA.time) {
			while (1) { }
		}
		int canProcessAFinishTime = firstA.time;
		prevProcAFinishTime = canProcessAFinishTime;
		firstA.time += firstA.execDuration;

		procAMinTime = getMax(procAMinTime, canProcessAFinishTime);
		procAHeap.push(firstA);

		while (procBHeap.size() && (procBHeap.top().time - procBHeap.top().execDuration < canProcessAFinishTime)) {
			HeapItem top = procBHeap.top();
			top.time = canProcessAFinishTime + top.execDuration;
			procBHeap.pop();
			procBHeap.push(top);
		}

		if (procBHeap.size() > 0) {
			//
			int canProcessBFinishTime;
			HeapItem firstB = procBHeap.top();
			procBHeap.pop();

			canProcessBFinishTime = firstB.time;
			firstB.time += firstB.execDuration;

			procBMinTime = getMax(procBMinTime, canProcessBFinishTime);
			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;
}